Java多线程之线程的互斥处理

一、前言

　　多线程程序中的各个线程都是自由运行的，所以它们有时就会同时操作同一个实例。这在某些情况下会引发问题。例如，从银行账户取款时，余额确认部分的代码应该是像下面这样的。

　　if (可用余额大于取款金额) {

　　　　从可用余额中减掉取款金额

　　}

　　首先确认可用余额，确认是否允许取款。如果允许，则从可用余额上减掉取款金额。这样才不会导致可用余额变为负数。

　　但是，如果两个线程同时执行这段代码，那么可用余额就有可能会变为负数。

　　假设可用余额＝1000元，取款金额＝ 1000元，那么这种情况就如下图所示：

　　线程A 和线程B 同时操作时，有时线程B 的处理可能会插在线程A 的“可用余额确认”和“从可用余额上减掉取款金额”这两个处理之间。

　　这种线程A 和线程B 之间互相竞争（race）而引起的与预期相反的情况称为数据竞争（datarace）或竞态条件（race condition）。

　　这时候就需要有一种“交通管制”来协助防止发生数据竞争。例如，如果一个线程正在执行某一部分操作，那么其他线程就不可以再执行这部分操作。这种类似于交通管制的操作通常称为互斥（mutual exclusion）。这种处理就像十字路口的红绿灯，当某一方向为绿灯时，另一方向则一定是红灯。

　　Java 使用关键字synchronized 来执行线程的互斥处理。

二、synchronized 方法

　　如果声明一个方法时，在前面加上关键字synchronized，那么这个方法就只能由一个线程运行。只能由一个线程运行是每次只能由一个线程运行的意思，并不是说仅能让某一特定线程运行。这种方法称为synchronized 方法，有时也称为同步方法。

　　如下所示的类就使用了synchronized 方法。Bank（银行）类中的deposit（存款）和withdraw（取款）这两个方法都是synchronized 方法。

　　包含deposit 和withdraw 这两个synchronized 方法的Bank 类（Bank.java）

 public class Bank {

     private int money;

     private String name;

     public Bank(String name, int money) {

     this.name = name;

     this.money = money;

     }

     /**

      * 存款

      * @param m

      */

     public synchronized void deposit(int m) {

     money += m;

     }

     /**

      * 取款

      * @param m

      * @return

      */

     public synchronized boolean withdraw(int m) {

     if (money >= m) {

         money -= m;

         return true; // 取款成功

     } else {

         return false; // 余额不足

     }

     }

     public String getName() {

     return name;

     }

 }

　　如果有一个线程正在运行Bank 实例中的deposit 方法，那么其他线程就无法运行这个实例中的deposit 方法和withdraw 方法，需要排队等候。

　　Bank 类中还有一个getName 方法。这个方法并不是synchronized 方法，所以无论其他线程是否正在运行deposit 或withdraw，都可以随时运行getName 方法。

　　一个实例中的synchronized 方法每次只能由一个线程运行，而非synchronized 方法则可以同时由两个以上的线程运行。下图展示了由两个线程同时运行getName 方法的情况。

　　synchronized 方法不允许同时由多个线程运行。上图中，我们在synchronized 方法左侧放了一个代表“锁”的长方形来表示这点。当一个线程获取了该锁后，长方形这块儿就像筑起的墙一样，可以防止其他线程进入。

　　下图展示了由一个线程运行deposit 方法的情况。由于该线程获取了锁，所以其他线程就无法运行该实例中的synchronized 方法。图中，表示锁的长方形被涂成了灰色，这表示该锁已被某一线程获取。

　　请注意，上图中，非synchronized 的getName 方法完全不受锁的影响。不管线程是否已经获取锁，都可以自由进入非synchronized 方法。

　　当正在使用synchronized 方法的线程运行完这个方法后，便会释放锁。下图中的长方形锁变为白色表示这个锁已被释放。

　　当锁被释放后，一直等待获取锁的线程中的某一个线程便会获取该锁。但无论何时，获取锁的线程只能是一个。如果等待的线程有很多个，那么没抢到的线程就只能继续等待。下图展示的是新获取锁的另一个线程开始运行synchronized 方法的情况。

　　每个实例拥有一个独立的锁。因此，并不是说某一个实例中的synchronized 方法正在执行中，其他实例中的synchronized 方法就不可以运行了，下图展示了bank1 和bank2 这两个实例中的synchronized 方法由不同的线程同时运行的情况。

关于锁和监视

　　线程的互斥机制称为监视（monitor）。另外，获取锁有时也叫作“拥有（own）监视”或“持有（hold）锁”。

　　当前线程是否已获取某一对象的锁可以通过Thread.holdsLock 方法来确认。当前线程已获取对象obj 的锁时，可使用assert 来像下面这样表示出来。

　　assert Thread.holdsLock(obj);

三、synchronized 代码块

　　如果只是想让方法中的某一部分由一个线程运行，而非整个方法，则可使用synchronized代码块，格式如下所示。

　　synchronized (表达式) {

　　　　.......................

　　}

　　其中的“表达式”为获取锁的实例。synchronized 代码块用于精确控制互斥处理的执行范围。

　　◆◆synchronized实例方法和synchronized代码块

　　假设有如下synchronized 实例方法。

　　synchronized void method() {

　　　　.......................

　　}

　　这跟下面将方法体用synchronized 代码块包围起来是等效的。

　　void method () {

　　　　synchronized (表达式) {

　　　　　　.......................

　　　　}

　　也就是说，synchronized 实例方法是使用this的锁来执行线程的互斥处理的。

　　◆◆synchronized静态方法和synchronized代码块

　　假设有如下synchronized 静态方法。synchronized 静态方法每次只能由一个线程运行，这一点和synchronized 实例方法相同。但synchronized 静态方法使用的锁和synchronized 实例方法使用的锁是不一样的。

　　Class Something {

　　　　static synchronized void method() {

　　　　　　.......................

　　　　}

　　这跟下面将方法体用synchronized代码块包围起来是等效的。

　　Class Something {

　　　　static void method() {

　　　　　　synchronized (Something.class) {

　　　　　　　　...................

　　　　　　}

　　也就是说，synchronized静态方法是使用该类的类对象的锁来执行线程的互斥处理的。Something.class是Something 类对应的java.lang.Class 类的实例。

参考：图解Java多线程设计模式