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、死锁

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