java多线程回顾3：线程安全

1、线程安全问题

关于线程安全问题，有一个经典案例：银行取钱问题。

假设有一个账户，有两个线程从账户里取钱，如果余额大于取钱金额，则取钱成功，反之则失败。

下面来看下线程不安全的程序会出什么问题。

账户类：

public class Account {

    public int balance = 10;//账户余额

   

    //取钱的方法

    public void draw(int money){

       if (balance >= money) {

           //此处让线程Thread-1睡眠1秒，是为了模拟线程不安全造成的错误

           if ("Thread-1".equals(Thread.currentThread().getName())) {

              try {

                  Thread.sleep(1000);

              } catch (InterruptedException e) {

                  e.printStackTrace();

              }

           }

          

           balance = balance - money;

           System.out.println(Thread.currentThread().getName()+"取钱成功，余额："+balance);

       }else{

           System.out.println("取钱失败，余额不足。余额："+balance);

       }

    }

}

取钱线程：

public class DrawThread implements Runnable{

    public Account account;

    public DrawThread(Account account){

       this.account = account;

    }

    @Override

    public void run() {

       //写个死循环，模拟不停取钱

       while(true){

           try {

              //此处睡眠500毫秒是为了让程序运行的慢一点，方便观察

              Thread.sleep(500);

           } catch (InterruptedException e) {

              e.printStackTrace();

           }

           //调用取钱方法，一次取4元

           account.draw(4);

       }

    }

}

测试类：

public class TestDraw {

    public static void main(String[] args) {

       //创建一个账户

       Account account = new Account();

       //创建两个线程，从同一个账户取钱

       DrawThread dtOne = new DrawThread(account);

       DrawThread dtTwo = new DrawThread(account);

       //启动线程

       new Thread(dtOne).start();

       new Thread(dtTwo).start();

    }

}

测试结果：

Thread-0取钱成功，余额：6

Thread-0取钱成功，余额：2

取钱失败，余额不足。余额：2

Thread-1取钱成功，余额：-2

取钱失败，余额不足。余额：-2

取钱失败，余额不足。余额：-2

这个结果显然是不对的，当余额小于取钱金额时，程序应该取钱失败，而不是把余额变成负数。之所以会出现这种情况，是因为当线程Thread-1通过balance >= money之后被阻塞了，这时候线程Thread-0也通过了balance >= money判断，并且把钱取走了。这之后，Thread-1重新开始运行，继续取钱，于是余额就变成负数了。

在实际的开发中，由于线程调度不可控，也可能出现类似的情况，所以对多线程操作一定要注意线程安全。

2、线程同步

为了解决线程安全问题，有三种方法：同步代码块、同步方法、同步锁。

同步代码块：

同步代码块的语法为：

synchronized (obj) {

    …

    //此处代码就是同步代码块

}

以上代码的obj叫做同步监视器，以上代码的含义是，线程开始执行同步代码块之前，必须获得对同步监视器的锁定。一般来说，我们把并发时共享的资源作为同步监视器，例子中账户就是共享的资源，所以写this，表示对象本身。

使用同步代码块改造的账户类如下：

   

 //取钱的方法

    public void draw(int money){

       //同步代码块开始

       synchronized (this) {

           if (balance >= money) {

              //此处让线程Thread-1睡眠1秒，是为了模拟线程不安全造成的错误

              if ("Thread-1".equals(Thread.currentThread().getName())) {

                  try {

                     Thread.sleep(1000);

                  } catch (InterruptedException e) {

                     e.printStackTrace();

                  }

              }

             

              balance = balance - money;

              System.out.println(Thread.currentThread().getName()+"取钱成功，余额："+balance);

           }else{

              System.out.println("取钱失败，余额不足。余额："+balance);

           }

       }

       //同步代码块结束

    }

同步方法：

同步方法即使用synchronized修饰方法，不用显示指定同步监视器，其同步监视器就是this，即对象本身。

使用同步方法改造的账户类如下：

//取钱的方法

    public synchronized void draw(int money){

       if (balance >= money) {

           //此处让线程Thread-1睡眠1秒，是为了模拟线程不安全造成的错误

           if ("Thread-1".equals(Thread.currentThread().getName())) {

              try {

                  Thread.sleep(1000);

              } catch (InterruptedException e) {

                  e.printStackTrace();

              }

           }

          

           balance = balance - money;

           System.out.println(Thread.currentThread().getName()+"取钱成功，余额："+balance);

       }else{

           System.out.println("取钱失败，余额不足。余额："+balance);

       }

    }

需要注意的是，synchronized不可以修饰属性和构造方法。

释放同步监视器的锁定

以下情况将释放对同步监视器的锁定：

• 同步方法（代码块）执行完毕。
• 执行中遇到return、break终止了同步方法（代码块）的执行。
• 同步方法（代码块）抛出了未处理的异常或错误。
• 调用了同步方法（代码块）的wait()方法，此时当前线程暂停，并释放对同步监视器的锁定。

以下情况不会释放对同步监视器的锁定：

• 调用sleep、yield方法，当前线程会暂停，但不会释放锁定。
• 其他线程调用了该线程的suspend方法将该线程挂起，该线程不会释放对同步监视器的锁定。注意，尽量不要使用suspend和resume方法，容易死锁。

同步锁

从JDK1.5开始，可以通过显示定义同步锁来实现线程安全。

使用方法和synchronized大同小异，基本上也是加锁—执行代码—解锁这么一个过程。

使用Lock改造的取钱方法如下：

   

 //定义锁对象

    private final Lock lock = new ReentrantLock();

    //取钱的方法

    public void draw(int money){

       //加锁

       lock.lock();

       try {

           if (balance >= money) {

              //此处让线程Thread-1睡眠1秒，是为了模拟线程不安全造成的错误

               if ("Thread-1".equals(Thread.currentThread().getName())) {

                  try {

                     Thread.sleep(1000);

                  } catch (InterruptedException e) {

                     e.printStackTrace();

                  }

              }

             

              balance = balance - money;

              System.out.println(Thread.currentThread().getName()+"取钱成功，余额："+balance);

           }else{

              System.out.println("取钱失败，余额不足。余额："+balance);

           }

       } finally {

           //为了确保解锁，放在finally里

           lock.unlock();

       }

    }

以上代码中，为了确保最后能释放锁，所以把解锁代码放在finally中。

和synchronized相比，Lock在使用上更灵活。上例中使用的是可重入锁，即线程可以对已加锁的代码再加锁。此外还有读写锁等。

3、死锁

两个线程相互等待对方释放对同步监视器的锁定，这种情况叫死锁。