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，这里就不在叙述了！