Java多线程的同步问题

在多线程的编程环境中，可能会有两个或者更多的线程试图同时访问一个有限的资源。必须对这种潜在的资源冲突进行预防。

解决办法：在线程使用一个资源的时候，我们为其加锁即可。访问资源的第一个线程为其加上锁以后，其它线程便不能访问那个资源，除非获得那个资源的线程对其解锁!

1、使用synchronized实现多线程的同步

首先我们先举一个大家都熟悉的例子，就是银行取钱的问题，有甲乙两个人同时对一个银行账户取钱,由于线程调度的不确定性，可能会出现错误；好了不多说了，来看下具体的代码

首先我们定义一个银行账户类.

public class Account {

//账户号码
private String accountNo;
//账户余额
private double balance;

public String getAccountNo() {
return accountNo;
}

public double getBalance() {
return balance;
}

public Account(){}

public Account(String accountNo, double balance) {
this.accountNo = accountNo;
this.balance = balance;
}

//取钱的方法
public  void draw (double drawAmount){
//账户余额大于取钱数目
if(balance >=drawAmount){
//吐出钞票
System.out.println(Thread.currentThread().getName() +" 取钱成功，吐出钞票"+drawAmount);

//			try {
//				Thread.sleep(1000);
//			} catch (InterruptedException e) {
//				e.printStackTrace();
//			}
//修改余额
balance=balance-drawAmount;
System.out.println("\t余额 :"+balance);
}else {
System.out.println(Thread.currentThread().getName()+"取钱失败，余额不足!");
}
}

}

然后我们定义一个取钱的线程类DrawThread：

public class DrawThread  implements Runnable{
private Account account;
private double drawAmonut;

public DrawThread(Account account, double drawAmonut) {
super();
this.account = account;
this.drawAmonut = drawAmonut;
}

public void run() {
account.draw(drawAmonut);
}
}

最后我们就来测试一下这个取钱的操作，有甲乙两个人，同时对这个账户取钱:

public class TestDraw {

public static void main(String[] args) {
//创建一个账户
Account account=new Account("1234567",1000);
//模拟两个线程对同一个账户操作

Thread t1=new Thread(new DrawThread(account,800),"甲");
Thread t2=new Thread(new DrawThread(account,800),"乙");

t1.start();
t2.start();

}
}

运行之后的输出结果可能是我们不想看到的.

甲 取钱成功，吐出钞票800.0
余额 :200.0
乙 取钱成功，吐出钞票800.0
余额 :-600.0

多次运行或者将Account类的注释代码取消注释后,几率会增大!

如果使用synchronized关键字对Account 账户对象进行加锁，将不会出现这样的问题；原因如下:当甲用户对这个账户取钱时，就获得了这个账户的对象，然后对这个账户进行加锁，知道这个账户的取钱动作完成(或者是其它的原因导致程序退出)，甲用户将释放这个锁，此后乙用户就可以对这个账户进行操作，然后加锁，完成一系列的取钱操作！

synchronized (accountNo) {
if(balance >=drawAmount){
//吐出钞票
System.out.println(Thread.currentThread().getName() +" 取钱成功，吐出钞票"+drawAmount);

try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//修改余额
balance=balance-drawAmount;
System.out.println("\t余额 :"+balance);
}else {
System.out.println(Thread.currentThread().getName()+"取钱失败，余额不足!");
}

}

上面同步代码块中的accountNo被称为"同步监视器".注意:在任何时刻只能有一个线程获得对同步监视器的锁定，当同步代码块执行结束之后，该线程就释放了对同步监视器的锁定！synchronized同步代码块的写法：

synchronized (object){

} //表示线程执行的时候会对object对象上锁.其中object应该是私有的。

修改之后再次运行程序，就会得到我们想要的结果！

甲 取钱成功，吐出钞票800.0
余额 :200.0
乙取钱失败，余额不足!

synchronized 也可以修饰方法，则该方法就称为同步方法.我们就拿上面的取钱账户来看看，当我们对Account账户的draw()方法使用synchronized关键字进行修饰时.

//取钱的方法
public synchronized  void draw (double drawAmount){
//账户余额大于取钱数目

if(balance >=drawAmount){
//吐出钞票
System.out.println(Thread.currentThread().getName() +" 取钱成功，吐出钞票"+drawAmount);

try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//修改余额
balance=balance-drawAmount;
System.out.println("\t余额 :"+balance);
}else {
System.out.println(Thread.currentThread().getName()+"取钱失败，余额不足!");
}
}

运行后和synchronized修饰的同步代码块效果是一样的.有一点需要注意的是：如果一个对象中的所有方法都用synchronized关键字修饰的话，则这个对象就称为同步锁！当调用一个对像的一个synchronized方法时，就会给这个对象上锁！其它对象就无法访问这个对象的synchronized方法！如果某个synchronized方法是static 方法的话，那么当线程访问该方法时，它锁的并不是synchronized所在的对象，而是synchronized方法所在对象的所对应的Class对象！
Class对象是唯一的，不管你new 了多少个对像，Class对像是唯一的！

2.Lock 实现线程的同步

在实现线程安全的控制中，通常喜欢使用ReentrantLock(可重入锁).使用该Lock对象可以显示的加锁，释放锁。关于这个所对象的说明，为了方面大家的参考，我从JDK文档上Copy了下：

一个可重入的互斥锁

Lock

，它具有与使用

synchronized

方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大。

ReentrantLock

将由最近成功获得锁，并且还没有释放该锁的线程所拥有。当锁没有被另一个线程所拥有时，调用

lock

的线程将成功获取该锁并返回。如果当前线程已经拥有该锁，此方法将立即返回。可以使用

isHeldByCurrentThread()

和

getHoldCount()

方法来检查此情况是否发生。

此类的构造方法接受一个可选的公平 参数。当设置为

true

时，在多个线程的争用下，这些锁倾向于将访问权授予等待时间最长的线程。否则此锁将无法保证任何特定访问顺序。与采用默认设置（使用不公平锁）相比，使用公平锁的程序在许多线程访问时表现为很低的总体吞吐量（即速度很慢，常常极其慢），但是在获得锁和保证锁分配的均衡性时差异较小。不过要注意的是，公平锁不能保证线程调度的公平性。因此，使用公平锁的众多线程中的一员可能获得多倍的成功机会，这种情况发生在其他活动线程没有被处理并且目前并未持有锁时。还要注意的是，未定时的

tryLock

方法并没有使用公平设置。因为即使其他线程正在等待，只要该锁是可用的，此方法就可以获得成功。

建议总是 立即实践，使用

lock

块来调用

try

，在之前/之后的构造中，最典型的代码如下：

class X {
private final ReentrantLock lock = new ReentrantLock();
// ...

public void m() {
lock.lock();  // block until condition holds
try {
// ... method body
} finally {
lock.unlock()
}
}
}

除了实现

Lock

接口，此类还定义了

isLocked

和

getLockQueueLength

方法，以及一些相关的

protected

访问方法，这些方法对检测和监视可能很有用。

该类的序列化与内置锁的行为方式相同：一个反序列化的锁处于解除锁定状态，不管它被序列化时的状态是怎样的。

此锁最多支持同一个线程发起的 2147483648 个递归锁。试图超过此限制会导致由锁方法抛出的

Error

。

对于这个同步锁，我们还是以上面的Account账户为例来说明：首先定义一个同步锁的对象，然后在draw()方法里对这个同步锁对象进行加锁，当方法体执行完后，在finally代码块里对这个锁对象进行解锁。

package com.thread.day1;

import java.util.concurrent.locks.ReentrantLock;

public class Account {
//定义锁对象
private  final ReentrantLock lock=new ReentrantLock();

//账户号码
private String accountNo;
//账户余额
private double balance;

public String getAccountNo() {
return accountNo;
}

public double getBalance() {
return balance;
}

public Account(){}

public Account(String accountNo, double balance) {
this.accountNo = accountNo;
this.balance = balance;
}

//取钱的方法 (线程安全)
public  void draw (double drawAmount){
//对同步锁进行加锁
lock.lock();
//账户余额大于取钱数目
try {
if (balance >= drawAmount) {
//吐出钞票
System.out.println(Thread.currentThread().getName()
+ " 取钱成功，吐出钞票" + drawAmount);

try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//修改余额
balance = balance - drawAmount;
System.out.println("\t余额 :" + balance);
} else {
System.out.println(Thread.currentThread().getName()
+ "取钱失败，余额不足!");
}
}
finally{
//解锁
lock.unlock();
}
}
}

关于ReentrantLock的是使用还有很多，具体的可以参考官方的API，这里就不在叙述了！