java学习之浅谈多线程2--线程同步

• 如果一个共享资源被多个线程同时访问，可能会遭到破坏。举个例子说明这个问题，假设创建并启动100个线程，每个线程都往同一个账户中添加一个便士，代码如下：

 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;

 public class AccountWithSync {

     private static Account account = new Account();

     public static void main(String[] args) {
         ExecutorService executor = Executors.newCachedThreadPool();

         //用线程池executor创建并启动100个线程
         for(int i=0; i<100; i++) {
             executor.execute(new AddAPennyTask());
         }

         executor.shutdown();

         //线程全部结束前执行此循环
         while(!executor.isTerminated()) {
         }

         System.out.println("What is balance?" + account.getBalance());
     }

     private static class AddAPennyTask implements Runnable {
         @Override
         public void run() {
             account.deposit(1);
         }
     }

     private static class Account {
         private int balance = 0;        //账户余额

         public int getBalance() {
             return balance;
         }

         public void deposit(int amount) {
             int newBalance = balance + amount;

             //设置这种延迟是为了加大数据的破坏程度让结果更加明显
             try {
                 Thread.sleep(5);
             } catch (InterruptedException e) {
             }

             balance = newBalance;
         }
     }
 }

该账户中的初始余额为0，当所有线程都结束时，余额应该为100，但是运行上面程序得到的结果却是不可预测的，如下图所示。它演示了当所有线程同时访问同一个数据时，就会出现数据破坏的问题。

那么，究竟是什么导致了程序的错误？下面给出一个可能的情况。

步骤	余额	任务1	任务2
1	0	newBalance = balance + 1;
2	0		newBalance = balance + 1;
3	1	balance = newBalance;
4	1		balance = newBalance;

在步骤1中，任务1从账户中获取余额数目。在步骤2中，任务2从账户中获取同样数目的余额。在步骤3中，任务1向账户写入一个新余额。在步骤4中任务2也向该账户写入一个新余额。这就导致任务1什么也没做，因为任务2覆盖了任务1的结果。

这是多线程程序中一个普遍的问题，称为竞争状态。如果一个类的对象在多线程程序中没有导致竞争状态，则称这样的类为线程安全的。

• 为了解决上面的问题，应该防止多个线程同时进入程序的某一个特定部分（程序中的这部分称为临界区），也就是将这部分同步化。下面介绍三种解决方法：

1.使用关键字synchronized
通过在程序的deposit方法中添加关键字synchronized，使Account类成为线程安全的，如下：

 public synchronized void deposit(double amount)

一个同步方法在执行前需要加锁。对于实例方法，要给调用该方法的对象加锁。对于静态方法，要给这个类加锁。如果一个线程调用一个对象上的同步实例方法（静态方法），首先给该对象（类）加锁，然后执行该方法，最后解锁。在解锁之前，另一个调用那个对象（类）中方法的线程将被阻塞，直到解锁。

因为deposit方法被同步化，如果任务1开始进入deposit方法，任务2就会被阻塞，直到任务1完成该方法的运行。

2.利用加锁同步
使用关键字synchronized的代码块在执行前都隐式地需要一个锁。还可以通过显示地加锁解决上面的问题。
一个锁是一个Lock接口的实例，它定义了加锁和释放锁的方法，如下：

 +lock():void                加锁
 +unlock():void              释放锁
 +newCondition():Condition   返回绑定到Lock实例的新的Condition实例

ReentrantLock是为了创建相互排斥的锁的Lock的具体实现。可以创建具有特定的公平策略的锁。真正的公平策略确保等待时间最长的线程首先获得锁。假的公平策略将锁给任意一个在等待的线程。被多个线程访问的使用公正锁的程序，齐整体性能可能比那些使用默认设置的程序差，但是在获取锁且避免资源缺乏时变化很小。

 +ReentrantLock()                等价于ReentrantLock(false)
 +ReentrantLock(fair:boolean)    创建具有给定公平策略的锁。当公平性为true时，等待时间最长的线程将获得锁；否则没有特定的获得顺序

使用显示锁修改程序中的Account类如下：

 private static class Account {
         private int balance = 0;
         private static Lock lock = new ReentrantLock();         //创建一个锁

         public int getBalance() {
             return balance;
         }

         //使用显示加锁避免竞争状态
         public void deposit(int amount) {
             lock.lock();            //获得锁

             try {
                 int newBalance = balance + amount;
                 Thread.sleep(5);
                 balance = newBalance;
             } catch (InterruptedException e) {
             }finally {
                 lock.unlock();      //释放锁
             }
         }
     }

在对lock()的调用之后紧随一个try-catch块并且在finally子句中释放这个锁是一个很好的习惯

通常使用synchronized方法或语句比使用排斥的显示锁简单些。然而，使用显示锁对同步具有状态的线程更加直观和灵活。

3.使用信号量
信号量可以用来限制访问共享资源的线程数。在访问资源之前，线程必须从信号量获取许可。在访问完资源之后，这个线程必须将许可返回给信号量。任务一旦获取许可，信号量中可用许可的总数量减1，一旦许可被释放，信号量中许可的总数加1.

 +Semaphore(numberOfPermits:int)                 创建一个带指定数目许可的信号量。公平策略为false
 +Semaphore(numberOfPermits:int, fair:boolean)   创建一个带指定数目许可和公平策略的信号量
 +acquire():void                                 获取这个信号量的许可。如果无许可可用，线程就被锁住直到有可用许可为止
 +release():void                                 释放一个许可给该信号量

只有一个许可的信号量可以用来模拟一个相互排斥的锁。修改程序中的Account类，确保同一时间只有一个线程访问deposit方法从而解决了上面的问题，代码如下。

 private static class Account {
         private int balance = 0;
         private static Semaphore semaphore = new Semaphore(1);  //创建只有一个许可的信号量

         public int getBalance() {
             return balance;
         }

         //使用只有一个许可的信号量避免竞争状态
         public void deposit(int amount) {
             try {
                 semaphore.acquire();        //  获得许可

                 int newBalance = balance + amount;
                 Thread.sleep(5);
                 balance = newBalance;
             } catch (InterruptedException e) {
             } finally {
                 semaphore.release();        //释放许可
             }
         }
     }