java线程互斥&同步（一）

Java线程互斥和同步一直是一个较难理解透彻的东西，要弄清楚其本真，还是要先从概念入手：

1、线程之间通过对资源的竞争，包括共享的数据和硬件资源，所产生的相互制约关系，这类线程间的主要问题是互斥和死锁问题，这类关系被称为互斥关系。
2、线程之间的相互协同合作，彼此之间直接知道对方的存在，并了解对方的名字，这类进程常常需要通过“进程间通信”方法来协同工作，这类关系被称为同步关系。

 

概念读几遍，至少能把互斥和同步分清楚，然后我们来详细看看互斥，以及java线程间怎么来实现互斥。

举个银行取钱的例子：一个用户有2000块钱，同时有两个人在操作这个账户进行取钱，一次取100块，分别取四次。

package bank_test;

public class UserGetMoney implements Runnable { // 模拟用户取款的线程类
	private static int sum = 2000;

	public void take(int k) {
		int temp = sum;
		temp -= k;
		try {
			Thread.sleep((int) (100 * Math.random()));
		} catch (InterruptedException e) {
		}
		sum = temp;
		System.out.println(Thread.currentThread() + "sum = " + sum);
	}
	
	int money = 0;
	public UserGetMoney(int money) {
		// TODO Auto-generated constructor stub
		this.money = money;
	}
	
	public void run() {
		for (int i = 1; i <= 4; i++) {
			take(money);
		}
	}
}

 以上是ATM机取钱的主类

 

package bank_test;

public class BankAdvance { // 调用线程的主类

	public static void main(String[] args) {
		UserGetMoney u1 = new UserGetMoney(100);
		new Thread(u1).start();
		new Thread(u1).start();
	}
}

 

运行结果：

Thread[Thread-1,5,main]sum = 1900
Thread[Thread-0,5,main]sum = 1900
Thread[Thread-1,5,main]sum = 1800
Thread[Thread-0,5,main]sum = 1800
Thread[Thread-0,5,main]sum = 1700
Thread[Thread-1,5,main]sum = 1700
Thread[Thread-1,5,main]sum = 1600
Thread[Thread-0,5,main]sum = 1600

 看到，结果两个人取了八次，账户只少了400块，明显是没有互斥，所以导致银行亏了1倍的钱。要解决这个问题，就要用到关键字synchronized了，它用于实现语句的同步操作，即给共享资源加互斥锁。

锁定一个对象和一段代码
声明格式为：
synchronized（<对象名 >）{

 <语句组>

}

锁定一个方法
声明格式为：
synchronized<方法声明 >{
 
 <方法体>

}

线程间的互斥

无论是对方法加互斥锁，还是对对象加互斥锁，其实质都是实现对共享资源的互斥访问
互斥操作是以降低应用程序的并发程度为代价的
因此，在编写多线程程序中，对synchronized的使用就遵循以下两个原则：
    -不需要再多个线程中使用共享资源时，那么就没有必要使用该关键字；
    -如果某个方法只是返回对象的值，而不去修改对象的值时，那么也就没有必要使用该关键字。

 

我们来改造下以上的代码：

package bank_test;

public class UserGetMoney implements Runnable { // 模拟用户取款的线程类
	private static int sum = 2000;

	public synchronized  void take(int k) { // 限定take为同步方法
		int temp = sum;
		temp -= k;
		try {
			Thread.sleep((int) (100 * Math.random()));
		} catch (InterruptedException e) {
		}
		sum = temp;
		System.out.println(Thread.currentThread() + "sum = " + sum);
	}
	
	int money = 0;
	public UserGetMoney(int money) {
		// TODO Auto-generated constructor stub
		this.money = money;
	}
	
	public void run() {
		for (int i = 1; i <= 4; i++) {
			take(money);
		}
	}
}

 

再来看看结果：

Thread[Thread-0,5,main]sum = 1900
Thread[Thread-0,5,main]sum = 1800
Thread[Thread-1,5,main]sum = 1700
Thread[Thread-1,5,main]sum = 1600
Thread[Thread-1,5,main]sum = 1500
Thread[Thread-1,5,main]sum = 1400
Thread[Thread-0,5,main]sum = 1300
Thread[Thread-0,5,main]sum = 1200

 这就是两个线程访问同一个对象（一个银行账户）时达到了互斥的效果，这是个原子操作，必须一个人取完钱，另一个人才能继续取钱。