死锁、饥饿、活锁、wait()、notifyAll()、notify()

死锁：两个或两个以上的线程互相等待彼此的锁。

举个栗子：

小明和小花是朋友，假设当有朋友拥抱自己的时候，自己必须要回应对方的拥抱，这样我们就定义两个方法，一个bow()拥抱方法，一个backBrow()回应拥抱方法。我们在bow方法中调用对方的backbow()方法来响应对方，具体代码如下：

package com.zrh.thread;

/**
 * 死锁例子
 * @author ljh
 *
 */
public class Deadlock {

	static class Friend{
		private String name;

		public Friend(String name) {
		
			this.name = name;
		}
		
		public String getName(){
			return this.name;
		}
		
		public synchronized void brow(Friend bower){
			System.out.format("%s:%s"+" has bowed to me!%n", this.name,bower.getName());
			bower.backBow(this);
		}
		
		public synchronized void backBow(Friend bower){
			System.out.format("%s:%s"+" has bowed back to me !%n", this.name,bower.getName());
		}
	}
	
	public static void main(String[] args) {
		final Friend xiaoHua = new Friend("xiaoHua");
		final Friend xiaoMing = new Friend("xiaoMing");
		
		new Thread(new Runnable() {			
			public void run() {
				
				xiaoHua.brow(xiaoMing);
			}
		}).start();
		
		new Thread(new Runnable() {
			
			public void run() {
				xiaoMing.brow(xiaoHua);
			}
		}).start();
	}
}

运行结果：

xiaoHua:xiaoMing has bowed to me!
xiaoMing:xiaoHua has bowed to me!
死锁中……

结果分析如下：

饥饿：线程不能正常的访问共享资源且不能正常的执行。如当有少数的线程暂用共享资源的时间太长，导致其他需要访问共享资源的线程经常被阻塞就会出现饥饿的情况。

活锁：线程不会被阻塞，但是无法继续执行，通常是线程间的相互响应导致的，类似行人在过道上的相互谦让，但两人总是向同一个方位移动，导致虽然互相谦让了，但还是无法顺利的通过，双发僵持不下，无法继续行走。对于活锁常见的解决方法是：采用使用先到先得，或者设置重试上限。

避免死锁和饥饿的设计技巧：使用wait

	public synchronized void doSomeThing(){
		while (flage) {
			try {
				wait();
			} catch (InterruptedException e) {
			
			}
		}
		//条件成立，开始工作
	}

注意：wait往往会搭配循环使用，避免在受notifyAll或中断的影响出现flage状态并没有变，线程却被唤醒的情况。

wait()、notifyAll()、notify():假设一个线程在获得A对象的锁的时候调用wait()时，将会释放锁并挂起。这时另外一个线程获得到了A对象的锁，并且执行完毕后调用了notifyAll()通知唤醒所有在等待A对象锁的线程去竞争A对象的锁。或者调用notify()，这样就只会唤醒一个线程，不能控制具体唤醒哪一个线程，适用于当我们处理许多相似的任务且不关心哪一个线程被唤醒的时候。（注意获得锁的线程，在执行完后一定要调用notifyAll()或notify()，否则就算获得锁的线程释放了锁，调用wait()方法等待该锁的线程也不会去竞争锁）

举个栗子：我们实现一个简单的生产者与消费者的场景.

消息管道类：

public class MeassgePipe {

	private String message;//信息从生产者发送给消费者
	private boolean empty = true;//标志位是否有信息
	
	public synchronized String take(){
		//如果当前无可以获取的消息就将线程挂起释放锁
		while (empty){
				try {
					wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}	
		}
		//有信息可以取的时候，就将信息取走，并重置标志位
		empty = true;	
		//当标识位状态为空为真的时候，通知生产者生成信息
		notifyAll();
		return message;
	}
	
	public synchronized void put(String message){
		while (!empty) {
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		//生产信息，并修改状态
		empty = false;	
		this.message = message;
		notifyAll();
	}
}

生产者：

public class Producer implements Runnable{

	private MeassgePipe pipe;
	
	public Producer(MeassgePipe pipe) {
		this.pipe = pipe;
	}

	public void run() {
		  String[] importantInfo = {"母马吃燕麦","狗吃骨头","小马吃草","小孩吃奶"};
		Random random = new Random();
		for (int i = 0; i < importantInfo.length; i++) {
			pipe.put(importantInfo[i]);
			try {
				Thread.sleep(random.nextInt(5000));
			} catch (Exception e) {
				// TODO: handle exception
			}
		}
		pipe.put("生产结束！");
	}

}

消费者：

package com.zrh.thread.produce_consumer;

import java.util.Random;

public class Consumer implements Runnable{

	MeassgePipe pipe;
	
	public Consumer(MeassgePipe pipe) {
		super();
		this.pipe = pipe;
	}

	public void run() {
		Random random = new Random();
		for (String message = pipe.take();!message.equals("生产结束！"); message = pipe.take()) {
			System.out.format("收到的信息为:%s%n",message);
		}
		try {
			Thread.sleep(random.nextInt(50000));
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

测试：

public class SimpleProducerConsumer {

	public static void main(String[] args) {
		MeassgePipe pipe = new MeassgePipe();
		new Thread(new Consumer(pipe)).start();
		new Thread(new Producer(pipe)).start();
	}
}

运行结果：

收到的信息为:母马吃燕麦
收到的信息为:狗吃骨头
收到的信息为:小马吃草
收到的信息为:小孩吃奶

死锁、饥饿、活锁、wait()、notifyAll()、notify()

猜你喜欢