多线程的死锁笔记

死锁的产生

同步锁的使用过程中,线程出现多个同步的时候,程序在唤醒线程的时候,有可能出现while (true) 但是唤醒的线程立刻等待的,这个时候就相当于一直在等待,这就是出现了死锁.

死锁的解决方案

在经典案例的生产者消费者中,我们可以唤醒其他全部线程,然后让其线程各自在其判断条件中决定是否运行,
生产者完成一次生产后唤醒其他的阻塞等待着的线程池中的生产者和其他全部消费者,再由他们自由的根据while循环的判断条件来判断是否运行和等待,但是下一次运行后的唤醒还是唤醒其他的全部.

死锁中判断条件的选用

if和while,需要了解的是if是单次判断,当语句判断完条件后,如果线程在判断完后进行等待和唤醒,那么容易发生线程安全问题
需要用while , 一直重复判断这个条件

jdk5以后的优化方法

这是一个封装好的同步锁和对象,可以利用其实现类调用lock(),和unlock(),方法来完成获取和释放锁

这个类创建一个对象可以产生一把锁,但是一把锁可以获取多组监视器,监视器之间可以相互通讯,唤醒指定的监视器组的监视对象,不需要唤醒全部,而之前的wait(),notify(),和notifyAll()也停用了,取而代之的是监视器接口Condition的方法

这里先简单插入学习视频中,毕向东老师的代码

/*
jdk1.5以后将同步和锁封装成了对象。 
并将操作锁的隐式方式定义到了该对象中，
将隐式动作变成了显示动作。

Lock接口： 出现替代了同步代码块或者同步函数。将同步的隐式锁操作变成现实锁操作。
同时更为灵活。可以一个锁上加上多组监视器。
lock():获取锁。
unlock():释放锁，通常需要定义finally代码块中。


Condition接口：出现替代了Object中的wait notify notifyAll方法。
			将这些监视器方法单独进行了封装，变成Condition监视器对象。
			可以任意锁进行组合。
await();等待
signal();唤醒
signalAll();唤醒全部



*/

import java.util.concurrent.locks.*;

class Resource
{
	private String name;
	private int count = 1;
	private boolean flag = false;

//	创建一个锁对象。
	Lock lock = new ReentrantLock();

	//通过已有的锁获取该锁上的监视器对象。
//	Condition con = lock.newCondition();

	//通过已有的锁获取两组监视器，一组监视生产者，一组监视消费者。
	Condition producer_con = lock.newCondition();
	Condition consumer_con = lock.newCondition();

	
	public  void set(String name)//  t0 t1
	{
		lock.lock();
		try
		{
			while(flag)
//			try{lock.wait();}catch(InterruptedException e){}//   t1    t0
			try{producer_con.await();}catch(InterruptedException e){}//   t1    t0
		
			this.name = name + count;//烤鸭1  烤鸭2  烤鸭3
			count++;//2 3 4
			System.out.println(Thread.currentThread().getName()+"...生产者5.0..."+this.name);//生产烤鸭1 生产烤鸭2 生产烤鸭3
			flag = true;
//			notifyAll();
//			con.signalAll();
			consumer_con.signal();
		}
		finally
		{
			lock.unlock();
		}
		
	}

	public  void out()// t2 t3
	{
		lock.lock();
		try
		{
			while(!flag)
//			try{this.wait();}catch(InterruptedException e){}	//t2  t3
			try{cousumer_con.await();}catch(InterruptedException e){}	//t2  t3
			System.out.println(Thread.currentThread().getName()+"...消费者.5.0......."+this.name);//消费烤鸭1
			flag = false;
//			notifyAll();
//			con.signalAll();
			producer_con.signal();
		}
		finally
		{
			lock.unlock();
		}
		
	}
}

class Producer implements Runnable
{
	private Resource r;
	Producer(Resource r)
	{
		this.r = r;
	}
	public void run()
	{
		while(true)
		{
			r.set("烤鸭");
		}
	}
}

class Consumer implements Runnable
{
	private Resource r;
	Consumer(Resource r)
	{
		this.r = r;
	}
	public void run()
	{
		while(true)
		{
			r.out();
		}
	}
}



class  ProducerConsumerDemo2
{
	public static void main(String[] args) 
	{
		Resource r = new Resource();
		Producer pro = new Producer(r);
		Consumer con = new Consumer(r);

		Thread t0 = new Thread(pro);
		Thread t1 = new Thread(pro);
		Thread t2 = new Thread(con);
		Thread t3 = new Thread(con);
		t0.start();
		t1.start();
		t2.start();
		t3.start();

	}
}