Java 线程的互斥机制

• 为什么要有互斥机制
  假设当多个线程对统一数据并发进行读写操作（即竞争），会导致数据的不确定性。
• 怎样实现互斥
  用锁机制，用synchronized关键字来标记必须原子执行的代码段，让多个线程有一共享对象，该对象有互斥锁，只有拿到，才能执行临界区；并且，临界区要么不执行，若执行，必须一次执行完。synchronized(D) { S; } //D是临界资源；S是临界区；

例

1. /*模拟银行存取钱，假定张三的银行帐户中有余额1000元，对银行账户的处理需要经历三次函数调用：
   显示余额、修改余额（存钱或取钱）、显示修改后的余额。
   这三次调用的输出信息分别是：
   XX帐户余额为……元\n
   向……帐户存入（或者取出）……元\n
   XX帐户余额为……元\n
   请构造3个线程来同时操纵上述帐户，并输出结果。如张三向其中存5000元，老婆取2000，儿子取4000
   */

class Account{
	private String name;
	private int val;
	public String getName() {
		return name;
	}
	Account(String s,int x){
		name = s;
		val = x;
	}
	public int getVal() { //查
		return val;
	}
	public void setVal(int x) { //改
		val = x;
	}
}
class Saver extends Thread{ //查-改-查
	private Account a;
	private String name;
	private int cm;
	Saver(Account x,String y,int z){
		a = x;
		name = y;
		cm = z;
	}
	public void run() {
		synchronized(a) {
			System.out.println(a.getName()+"账户余额为"+a.getVal()+"元");		
			System.out.println(name+"向"+a.getName()+"账户存入"+cm+"元");
			int x = a.getVal()+cm;
			a.setVal(x);
			System.out.println(a.getName()+"账户余额为"+x+"元\n");
		}
	}
}
class Fetcher extends Thread{ //查-改-查
	private Account a;
	private String name;
	private int qm;
	Fetcher(Account x,String y,int z){
		a = x;
		name = y;
		qm = z;
	}
	public void run() {
		synchronized(a) {
			System.out.println(a.getName()+"账户余额为"+a.getVal()+"元");		
			System.out.println(name+"向"+a.getName()+"账户取出"+qm+"元");		
			int x = a.getVal()-qm;
			a.setVal(x);
			System.out.println(a.getName()+"账户余额为"+x+"元\n");
		}
	}
}
class app{
	public static void main(String [] args) {
		Account a = new Account("张三",1000);
		Saver s1 = new Saver(a,"张三",5000);
		Fetcher f1 = new Fetcher(a,"老婆",2000);
		Fetcher f2 = new Fetcher(a,"儿子",4000);
		s1.start(); f1.start(); f2.start();
	}
}

此例中：
临界区为查-改-查，此处必须原子执行，即一次执行完。
注：
不能在Account类中synchronized(a){ public int getVal() { return val; } }//查 synchronized(a){ public void setVal(int x) { val = x; } } //改，这样只能保证查和改操作是原子执行，而需求是查-改-查三步原子执行。

2. /*线程类T定义方式为：class T implements Runnable{ int data; …}
   线程体实现依次输出data的1~10倍数据。
   在main中，构造和启动线程的方式形如： T t=new T(2); t.start();
   构造data分别为2、3、5的线程，线程名分别为t2、t3、t5，要求：t2、t3、t5分3行输出，且输出结果不得交叉。
   */

class T implements Runnable{
	private int data;
	Thread t;
	public void start() { t.start();}
	String flag;
	T(String x,int y){
		flag = x;
		data = y;
		t = new Thread(this);
	}
	public void run() {
		synchronized(flag) { //注意这里共享资源，也可以直接填"a"，但不安全！此处涉及到常量池的概念
			System.out.print("开始");
			for(int i=1;i<=10;i++)
				System.out.print(data*i+" ");
			System.out.println("结束");
		}
	}
}
class app{
	public static void main(String [] args) {
		String s = "a";
		T t2 = new T(s,2);
		T t3 = new T(s,3);
		T t5 = new T(s,5);
		t2.start(); t3.start(); t5.start();
	}
}