java多线程（5）- 死锁与线程协作

死锁是多个线程自己持有一部分资源并且互相等待对方手里的资源，从而形成循环等待，无法向下执行的状态。某个同步块同时拥有“两个以上的对象的锁”时，就可能发生死锁。
如下代码，当一个人持有镜子的锁而在等待口红的锁，另一人持有口红的锁而在等待镜子的锁时，就发生死锁。所以我们写代码时要注意不要造成死锁。

//死锁：多个线程互相抱着对方需要的资源，然后形成僵持
public class DeadLock {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Makeup g1 = new Makeup(0,"灰姑凉");
		Makeup g2 = new Makeup(1,"白雪公主");
		
		g1.start();
		g2.start();
	}

}

class Lipstick{
	
}

class Mirror{
	
}

class Makeup extends Thread{
	
	//需要的资源只有一份，用static来保证只有一份
	static Lipstick lipstick = new Lipstick();
	static Mirror mirror = new Mirror();
	
	int choice;//选择
	String girlName;//使用化妆品的人
	Makeup(int choice,String girlName){
		this.choice = choice;
		this.girlName = girlName;
	
	}
	
	@Override
	public void run() {
		//化妆
		try {
			makeup();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	//化妆，互相持有对方的锁，就是需要拿到对方的资源
	private void makeup() throws InterruptedException {
		if(choice==0) {
			synchronized (lipstick) {
				//获得口红的锁
				System.out.println(this.girlName+"获得口红的锁");
				Thread.sleep(2000);
				synchronized(mirror) {
					//一秒钟后想获得镜子的锁
					System.out.println(this.girlName+"获得镜子的锁");
				}
			}
		}else {
			synchronized (mirror) {
				//获得镜子的锁
				System.out.println(this.girlName+"获得镜子的锁");
				Thread.sleep(2000);
				synchronized(lipstick) {
					//2秒钟后想获得口红的锁
					System.out.println(this.girlName+"获得口红的锁");
				}
			}
			
		}
	}
}

线程协作，不同线程之间的通信。如经典的生产者消费者模型。

//测试：生产者消费者模型--》利用缓冲区解决：管程法

//生产者，消费者，产品，缓冲区
public class testPC {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		SynContainer container = new SynContainer();
		
		new Producer(container).start();
		new Consumer(container).start();
	}

}

//生产者
class Producer extends Thread{
	
	SynContainer container;
	public Producer(SynContainer container) {
		this.container = container;
	}
	
	//生产
	public void run() {
		for(int i = 0; i < 100; i++) {
			
			container.push(new Chicken(i));
			System.out.println("生产了"+i+"只鸡");
		}
	}
}

//消费者
class Consumer extends Thread{
	SynContainer container;
	
	public Consumer(SynContainer container) {
		this.container = container;
	}
	
	
	//消费
	public void run() {
		for(int i = 0;i < 100; i++) {
			System.out.println("消费了--》"+container.pop().id+"只鸡");
		}
	}
}

//产品
class Chicken{
	int id;//产品编号
	
	public Chicken(int id) {
		this.id = id;
	}
	
}

//缓冲区
class SynContainer{
	
	//需要一个容器大小
	Chicken[] chickens = new Chicken[10];
	//容器计数器
	int count = 0;
	
	//生产者放入产品
	public synchronized void push(Chicken chicken) {
		//如果容器满了，就需要等待消费者消费
		if(count==chickens.length) {
			//通知消费者消费，生产等待
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
		//如果没有满，我们就需要对如产品
		chickens[count] = chicken;
		count++;
		
		//可以通知消费者消费了
		this.notifyAll();
	}
	
	public synchronized Chicken pop() {
		//判断能否消费
		if(count==0) {
			//等待生产者生产，消费者等待
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
		//如果可以消费
		count--;
		Chicken chicken = chickens[count];
		
		//吃完了，通知生产者生产
		this.notifyAll();
		return chicken;
	}
	
}