多线程：线程同步

一、线程安全问题

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码，如果程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

多线程安全问题，是由于多个线程在访问共享的资源，并且操作共享资源的语句不止一条，那么在多条操作共享资源之间的线程可能发生切换。只要切换就会产生安全问题。

下面举个银行取款的例子：

先编写一个账户类Account：

public class Account {private String accountNo;private double balance;public Account(String accountNo, double balance) {this.accountNo = accountNo;this.balance = balance;}@Overridepublic int hashCode() {return accountNo.hashCode();}@Overridepublic boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;Account other = (Account) obj;if (accountNo == null) {if (other.accountNo != null)return false;} else if (!accountNo.equals(other.accountNo))return false;return true;}public double getBalance() {return balance;}public void setBalance(double balance) {this.balance = balance;}public void withdraw(double drawAccount) {if (getBalance() >= drawAccount) {System.out.println(Thread.currentThread().getName() + "取款成功！取出：" + drawAccount + "元！");setBalance(getBalance() - drawAccount);System.out.println("\t余额为：" + getBalance() + "元！");} else {System.out.println(Thread.currentThread().getName() + "取钱失败！余额不足！");}}}

再编写模拟取款操作的线程DrawThread：

public class DrawThread extends Thread {private Account account;private double drawAccount;public DrawThread(String name, Account account, double drawAccount) {super(name);//设置线程名this.account = account;this.drawAccount = drawAccount;}public void run() {account.withdraw(drawAccount);}}

最后编写测试类DrawTest：

public class DrawTest {public static void main(String[] args) {Account account = new Account("账户", 1000);// 模拟两个线程对同一个账户取钱new DrawThread("张三", account, 800).start();new DrawThread("李四", account, 800).start();}}

运行结果：

李四取款成功！取出：800.0元！张三取款成功！取出：800.0元！余额为：200.0元！余额为：-600.0元！

运行后发现结果出现错误，这是因为多线程调度的不确定性，使两个线程同时操作共享资源引起的。

二、同步代码块

为了解决上面出现的问题，java的多线程引用同步监视器来解决这个问题。java有两种线程同步机制：1.同步代码块；2.同步方法。

同步代码块的语法格式如下：

synchronized (锁对象) {    可能会产生线程安全问题的代码}

同步代码块中的锁对象可以是任意的对象；但多个线程时，要使用同一个锁对象才能够保证线程安全。

下面使用同步代码块来修改Account的withdraw（）方法

public class Account {private String accountNo;private double balance;private Object obj = new Object(); // 作为同步监视器public Account(String accountNo, double balance) {this.accountNo = accountNo;this.balance = balance;}@Overridepublic int hashCode() {return accountNo.hashCode();}@Overridepublic boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;Account other = (Account) obj;if (accountNo == null) {if (other.accountNo != null)return false;} else if (!accountNo.equals(other.accountNo))return false;return true;}public double getBalance() {return balance;}public void setBalance(double balance) {this.balance = balance;}public void withdraw(double drawAccount) {synchronized (obj) {if (getBalance() >= drawAccount) {System.out.println(Thread.currentThread().getName() + "取款成功！取出：" + drawAccount + "元！");setBalance(getBalance() - drawAccount);System.out.println("\t余额为：" + getBalance() + "元！");} else {System.out.println(Thread.currentThread().getName() + "取钱失败！余额不足！");}}}}

运行结果：

张三取款成功！取出：800.0元！余额为：200.0元！李四取钱失败！余额不足！

运行结果正确，但明显感觉运行时间变长

三、同步方法

同步代码块的语法格式如下：

public synchronized void method() {    可能会产生线程安全问题的代码}

同步方法中的锁对象是 this

下面使用同步方法来修改Account的withdraw（）方法

package demo.sync.method;public class Account {private String accountNo;private double balance;private Object obj = new Object(); // 作为同步监视器public Account(String accountNo, double balance) {this.accountNo = accountNo;this.balance = balance;}@Overridepublic int hashCode() {return accountNo.hashCode();}@Overridepublic boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;Account other = (Account) obj;if (accountNo == null) {if (other.accountNo != null)return false;} else if (!accountNo.equals(other.accountNo))return false;return true;}public double getBalance() {return balance;}public void setBalance(double balance) {this.balance = balance;}public synchronized void withdraw(double drawAccount) {if (getBalance() >= drawAccount) {System.out.println(Thread.currentThread().getName() + "取款成功！取出：" + drawAccount + "元！");setBalance(getBalance() - drawAccount);System.out.println("\t余额为：" + getBalance() + "元！");} else {System.out.println(Thread.currentThread().getName() + "取钱失败！余额不足！");}}}

运行结果与同步代码块的结果一样

四、同步锁（Lock接口）

从Java5开始，Java提供一种功能更强大的线程同步机制——通过显示定义同步锁对象来实现同步，在这种机制下，同步锁由Lock对象充当。

虽然 synchronized 方法和语句的范围机制使得使用监视器锁编程方便了很多，而且还帮助避免了很多涉及到锁的常见编程错误，但有时也需要以更为灵活的方式使用锁。

import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class Account {private String accountNo;private double balance;// 定义可重入的互斥锁对象private final Lock lock = new ReentrantLock();public Account(String accountNo, double balance) {this.accountNo = accountNo;this.balance = balance;}@Overridepublic int hashCode() {return accountNo.hashCode();}@Overridepublic boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;Account other = (Account) obj;if (accountNo == null) {if (other.accountNo != null)return false;} else if (!accountNo.equals(other.accountNo))return false;return true;}public double getBalance() {return balance;}public void setBalance(double balance) {this.balance = balance;}public void withdraw(double drawAccount) {lock.lock();// 加锁try {if (getBalance() >= drawAccount) {System.out.println(Thread.currentThread().getName() + "取款成功！取出：" + drawAccount + "元！");setBalance(getBalance() - drawAccount);System.out.println("\t余额为：" + getBalance() + "元！");} else {System.out.println(Thread.currentThread().getName() + "取钱失败！余额不足！");}} finally {// 使用finally来保证一定会释放锁lock.unlock();//释放锁}}}

运行结果同上。

五、死锁

死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。

产生死锁的四个必要条件：

•  互斥条件：一个资源每次只能被一个进程使用。 
•  请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
•  不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
•  循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

public class DeadLock extends Thread {LockA a = new LockA();LockB b = new LockB();public static void main(String[] args) {DeadLock d = new DeadLock();d.start();d.init();}public void run() {b.first(a);System.out.println("进入" + Thread.currentThread().getName() + "之后");}public void init() {a.first(b);System.out.println("进入" + Thread.currentThread().getName() + "之后");}}class LockA {public synchronized void first(LockB b) {System.out.println("当前线程名：" + Thread.currentThread().getName() + "进入A的frist方法");try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("当前线程名：" + Thread.currentThread().getName() + "准备调用B的last方法");b.last();}public synchronized void last() {System.out.println("当前线程名：" + Thread.currentThread().getName() + "进入A的last方法");}}class LockB {public synchronized void first(LockA a) {System.out.println("当前线程名：" + Thread.currentThread().getName() + "进入B的frist方法");try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("当前线程名：" + Thread.currentThread().getName() + "准备调用A的last方法");a.last();}public synchronized void last() {System.out.println("当前线程名：" + Thread.currentThread().getName() + "进入B的last方法");}}

运行结果：

当前线程名：main进入A的frist方法当前线程名：Thread-0进入B的frist方法当前线程名：main准备调用B的last方法当前线程名：Thread-0准备调用A的last方法

由结果可以看出main线程获得A锁后想要获取B锁，Thread-0获得B锁想要获取A锁，但两个线程都不肯放开资源，所以处于死锁状态，运行后可以看到程序一直处于运行状态。

注意：

1.多个线程想保证线程安全，必须要使用同一个锁对象.

• 同步代码块

synchronized (锁对象) {    可能会产生线程安全问题的代码}

同步代码块中的锁对象可以是任意的对象；但多个线程时，要使用同一个锁对象才能够保证线程安全。

• 同步方法

public synchronized void method() {    可能会产生线程安全问题的代码}

同步方法中的锁对象是 this

• 静态同步方法

public static synchronized void method() {    可能会产生线程安全问题的代码}

同步方法中的锁对象是 本类类名.class

2.不可变类总是线程安全的，因为它的对象状态不可；但可变对象需要额外的方法来保证其线程安全。

可变类的线程安全是以降低程序的运行效率作为代价的，为了减少线程安全所带来的负面影响，程序可以采用一下策略：

• 不要对线程安全类的所有方法都进行同步，只对那些会改变共享资源的方法 进行同步。
• 如果可变类有两种运行环境：单线程环境和多线程环境，则需要为该可变类提供两个版本，即线程安全版本和线程不安全版本。例如JDK所提供的StringBuffer、StringBuilder就是为了解决不同环境所提供的类，在单线程环境下应该使用StringBuilder来保证较好的性能；但需要保证多线程安全的时候就使用StringBuffer。

3.为了保证同步锁一定会释放，必须谨慎地确保保持锁定时所执行的所有代码用 try-finally 或 try-catch 加以保护，以确保在必要时释放锁。在大多数情况下，应该使用以下语句：

     Lock l = ...;      l.lock();     try {         // access the resource protected by this lock     } finally {         l.unlock();     }

4.线程在如下几种情况释放同步监视器：

• 当前线程的同步方法、同步代码块执行结束。
• 当前线程在同步方法、同步代码块中遇到break、return终止了该代码块、该方法继续运行。
• 当前线程在同步方法、同步代码块中出现了未处理的error或Exception，导致该代码块、该方法异常结束时。
• 当前线程执行同步方法、同步代码块时，程序执行了同步监视器对象的wait()方法，则当前线程暂停。

线程在如下几种情况不会释放同步监视器：

• 线程执行同步代码块或同步方法时，程序调用Thread .sleep()、Thread.yield()方法来暂停当前线程的执行时。
• 线程执行同步代码块或同步方法时，其他线程调用了该线程的suspend()方法将该线程挂起。（程序应尽量避免使用suspend()和resume()方法来控制线程）