JAVA线程同步的方法及对比

1.提出问题

当多个用户对同一个银行账户进行操作或多个乘客购买车票时，应提前对账户进行检查，看余额或余票是否足够。这时我们就利用多线程，使用Runnable方式，开发一个取款、售票的线程类，将每一个用户对应一个线程对象，用多线程共享的方式去解决此类问题。

2.发现问题（以银行取款为例）

当我们遇到银行取款问题时，一般会使用以下的代码进行编写，经过多次运行，发现每次代码的结构都是正确的，这是因为CPU的运行速度较快，未出现并发运行的情况，导致小李取款成功、小红失败。

代码为：

public class Account {
	private int balance=600;
	//取款
	public void subMoney(int money) {
		this.balance=this.balance-money;
	}
	//返回余额
	public int getBalance() {
		return balance;
	}
}

public class AccountRunnable implements Runnable{
	private Account account=new Account();
	@Override
	public void run() {
		// TODO Auto-generated method stub
		if(account.getBalance()>=400) {
			account.subMoney(400);
			System.out.println(Thread.currentThread().getName()+"取款成功，余额为"+account.getBalance());
		}
		else 
		{
			System.out.println(Thread.currentThread().getName()+"余额不足，余额为"+account.getBalance());
		}
	}
}

public class Test {
	public static void main(String[] args) {
		Runnable runnable=new AccountRunnable();
		Thread xiaoli=new Thread(runnable,"小李");
		Thread xiaohong=new Thread(runnable,"小红");
		xiaoli.start();
		xiaohong.start();
	}
}

结果为：

小李取款成功，余额为200
小红余额不足，余额为200

当我们用Thread.sleep(1)让CPU休息1ms时，就会将问题放大，出现小李、小红取款都成功，余额为-200的情况。

代码为：

public class Account {
	private int balance=600;
	//取款
	public void subMoney(int money) {
		this.balance=this.balance-money;
	}
	//返回余额
	public int getBalance() {
		return balance;
	}
}
public class AccountRunnable implements Runnable{
	private Account account=new Account();
	@Override
	public void run() {
		// TODO Auto-generated method stub
		if(account.getBalance()>=400) {
			try {
				Thread.sleep(1);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			account.subMoney(400);
			System.out.println(Thread.currentThread().getName()+"取款成功，余额为"+account.getBalance());
		}
		else 
		{
			System.out.println(Thread.currentThread().getName()+"余额不足，余额为"+account.getBalance());
		}
	}
}
public class Test {
	public static void main(String[] args) {
		Runnable runnable=new AccountRunnable();
		Thread xiaoli=new Thread(runnable,"小李");
		Thread xiaohong=new Thread(runnable,"小红");
		xiaoli.start();
		xiaohong.start();
	}
}

结果为：

小李取款成功，余额为-200
小红取款成功，余额为-200

3.解决问题（以银行取款为例）

从上面的案例我们可以看到，当多个线程访问一个数据是，容易出现线程安全问题。需要让线程同步，保证数据安全。接下来将介绍三种线程同步的方法：同步代码块、同步方法和Lock锁，来解决线程同步问题。

同步代码块

使用同步代码块的代码如下：

public class Account {
	private int balance=600;
	//取款
	public void subMoney(int money) {
		this.balance=this.balance-money;
	}
	//返回余额
	public int getBalance() {
		return balance;
	}
}
public class AccountRunnable implements Runnable{
	private Account account=new Account();
	@Override
	public void run() {
		// TODO Auto-generated method stub
		synchronized (account) {
			if(account.getBalance()>=400) {
				try {
					Thread.sleep(1);
				} catch (Exception e) {
					// TODO: handle exception
					e.printStackTrace();
				}
				account.subMoney(400);
				System.out.println(Thread.currentThread().getName()+"取款成功，余额为"+account.getBalance());
			}
			else 
			{
				System.out.println(Thread.currentThread().getName()+"余额不足，余额为"+account.getBalance());
			}
		}
	}
}
public class Test {
	public static void main(String[] args) {
		Runnable runnable=new AccountRunnable();
		Thread xiaoli=new Thread(runnable,"小李");
		Thread xiaohong=new Thread(runnable,"小红");
		xiaoli.start();
		xiaohong.start();
	}
}

应用同步代码块的方法，及时让CPU休眠，也能得到正确的结果。

结果为： 

小李取款成功，余额为200
小红余额不足，余额为200

同步代码块的相关知识：

①认识同步监视器（锁子） synchronized(同步监视器){        }

必须是引用数据类型，不能是基本数据类型。在同步代码块中可以改变同步监视器对象的值，不能改变其引用。尽量不要String和包装类Integer做同步监视器。如果使用了，只要保证代码块中不对其进行任何操作也没有关系。一般使用共享资源做同步监视器即可，也可以创建一个专门的同步监视器。

②同步代码块的执行过程

第一个线程来到同步代码块，发现同步监视器open状态，需要close,然后执行其中的代码。第一个线程执行过程中，发生了线程切换（阻塞 就绪），第一个线程失去了cpu，但是没有开锁open。第二个线程获取了cpu，来到了同步代码块，发现同步监视器close状态，无法执行其中的代码，第二个线程也进入阻塞状态。第一个线程再次获取CPU,接着执行后续的代码；同步代码块执行完毕，释放锁open。第二个线程也再次获取cpu，来到了同步代码块，发现同步监视器open状态，重复第一个线程的处理过程（加锁）。

同步方法

使用同步方法的代码如下：

public class Account {
	private int balance=600;
	//取款
	public void subMoney(int money) {
		this.balance=this.balance-money;
	}
	//返回余额
	public int getBalance() {
		return balance;
	}
}
public class AccountRunnable implements Runnable{
	private Account account=new Account();
	@Override
	public void run() {
		// TODO Auto-generated method stub
		if(account.getBalance()>=400) {
			account.subMoney(400);
			System.out.println(Thread.currentThread().getName()+"取款成功，余额为"+account.getBalance());
		}
		else 
		{
			System.out.println(Thread.currentThread().getName()+"余额不足，余额为"+account.getBalance());
		}
	}

    public synchronized void sybMoney() {
    	 try 
    	 {
			Thread.sleep(1);
		 } 
    	 catch (Exception e) 
    	 {
			
			// TODO: handle exception
			if(account.getBalance()>=400)
			{
				account.subMoney(400);
				System.out.println(Thread.currentThread().getName()+"取款成功，余额为"+account.getBalance());
			}
			else 
			{
				System.out.println(Thread.currentThread().getName()+"余额不足，余额为"+account.getBalance());
			}

		 }
     }
}
public class Test {
	public static void main(String[] args) {
		Runnable runnable=new AccountRunnable();
		Thread xiaoli=new Thread(runnable,"小李");
		Thread xiaohong=new Thread(runnable,"小红");
		xiaoli.start();
		xiaohong.start();
	}
}

结果为： 

小李取款成功，余额为200
小红余额不足，余额为200

同步方法的相关知识：

不能将run()定义为同步方法。同步方法的同步监视器是this。同步代码块的效率要高于同步方法，同步方法的锁是this，一旦锁住一个方法，就锁住了所有的同步方法；同步代码块只是锁住使用该同步监视器的代码块，而没有锁住使用其他监视器的代码块。同步方法是将线程锁在了方法的外部，而同步代码块锁将线程锁在了代码块的外部，但是却是方法的内部。

 Lock锁

JDk1.5中，新增了Lock锁，与采用synchronized相比，lock可提供多种锁方案，更灵活。

使用Lock锁的代码如下：

public class Account {
	private int balance=600;
	//取款
	public void subMoney(int money) {
		this.balance=this.balance-money;
	}
	//返回余额
	public int getBalance() {
		return balance;
	}
}
public class AccountRunnable implements Runnable{
	private Account account=new Account();
	Lock lock=new ReentrantLock();
	@Override
	public void run() {
		// TODO Auto-generated method stub
		try {
			
			lock.lock();
			
			if(account.getBalance()>=400) 
			{
				try
				{
					Thread.sleep(1);
				} 
				catch (Exception e) 
				{
					// TODO: handle exception
					e.printStackTrace();
				}
				account.subMoney(400);
				System.out.println(Thread.currentThread().getName()+"取款成功，余额为"+account.getBalance());
			}
			else 
			{
				System.out.println(Thread.currentThread().getName()+"余额不足，余额为"+account.getBalance());
			}
		}
		finally 
		{
			lock.unlock();
		}
		
	}
}
public class Test {
	public static void main(String[] args) {
		Runnable runnable=new AccountRunnable();
		Thread xiaoli=new Thread(runnable,"小李");
		Thread xiaohong=new Thread(runnable,"小红");
		xiaoli.start();
		xiaohong.start();
	}
}

结果为：

小李取款成功，余额为200
小红余额不足，余额为200

 

Lock的相关知识：

①java.util.concurrent.lock 中的 Lock 框架是锁定的一个抽象，它允许把锁定的实现作为 Java 类，而不是作为语言的特性来实现，这就为 Lock 的多种实现留下了空间，各种实现可能有不同的调度算法、性能特性或者锁定语义。ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，  但是添加了类似锁投票、定时锁等候和可中断锁等候的一些特性。此外，它还提供了在激烈争用情况下更佳的性能。注意：如果同步代码有异常，要将unlock()写入finally语句块

②Lock和synchronized的区别

Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，遇到异常自动解锁。Lock只有代码块锁，synchronized有代码块锁和方法锁。Lock锁可以对读不加锁，对写加锁，synchronized不可以。Lock锁可以有多种获取锁的方式，可以从sleep的线程中抢到锁，synchronized不可以。使用Lock锁，JVM将花费较少的时间来调度线程，性能更好，并且具有更好的扩展性（提供更多的子类）。

③优先使用顺序：

Lock--同步代码块（已经进入了方法体，分配了相应资源）--同步方法（在方法体之外）