Java第十四天学习笔记~多线程（线程直接通信---等待唤醒机制、多生产者多消费者问题、JDK1.5新特性、wait和sleep区别）

本文链接：https://blog.csdn.net/crazyhulu/article/details/84868936

线程直接通信示例

//资源
class Resource
{
	String name;
	String sex;
}
//输入
class Input implements Runnable
{
	Resource r;
	Input(Resource r)
	{
		this.r=r;
	}
	public void run()
	{
		int x=0;
		while(true)
		{
			if(x==0)
			{
				r.name="mike";
				r.sex="nan";
			}
			else
			{
				r.name="丽丽";
				r.sex="女女女女女女女女女女";
			}
			x=x++%2;
			
		}
	}
}
//输出

class Output implements Runnable
{
	Resource r;
	Output(Resource r)
	{
		this.r=r;
	}
	public void run()
	{
		while(true)
		{
			System.out.println(r.name+"...."+r.sex);
		}
	}
}

class ResourceDemo
{
	public static void main(String[] args)
	{
		//创建资源
		Resource r=new Resource();
		//创建任务
		Producer in=new Producer(r);
		Consumer out=new Consumer(r);
		//创建线程
		Thread t1=new Thread(in);
		Thread t2=new Thread(out);
		//开启线程
		t1.start();
		t2.start();
	}
}

等待唤醒机制

涉及的方法：

wait( ):让线程处于冻结状态，被wait的线程会被存储到线程池中
notify（）：唤醒线程池中一个线程（任意）
notifyAll（）：唤醒线程池中的所有线程

这些方法是用于操作线程状态的方法

必须要明确到底操作的是哪个锁上的线程

为什么操作线程的方法 wait notify notifyAll 定义在了Object类中

因为这些方法是监视器方法，监视器其实就是锁，锁可以是任意对象，任意对象调用的方式一定定义在Object类中

多生产者多消费者问题

/*多生产者多消费者*/


class Resource
{
	private String name;
	private int count=1;
	private boolean flag = false;
	public synchronized void set (String name)
	{
		while(flag)
			try{this.wait();}catch(InterruptedException e){};//t1  t0
		this.name=name+count;//烤鸭1  烤鸭2 烤鸭3
		count++;//2 3 4
		System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);//生产烤鸭1  生产烤鸭2 生产烤鸭3
		flag=true;
		notify();
	}
	public synchronized void out()//t3
	{
		while(!flag)
			try{this.wait();}catch(InterruptedException e){};//t2 t3
		
		System.out.println(Thread.currentThread().getName()+"...消费者..."+this.name);//消费烤鸭1
		flag=false;
		notify();
	}
}
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 ProducerConsumerDemo
{
	public static void main(String[] args)
	{
		Resource r=new Resource();
		Producer pro=new Producer(r);
		Consumer con=new Consumer(r);
		
		Thread t1=new Thread(pro);
		Thread t2=new Thread(con);
		t1.start();
		t2.start();
	}
}

while标记，解决了线程换区执行权后是否要运行

notifyAll解决了，本方线程一定会唤醒对方线程

notify：只能唤醒一个线程，唤醒本方线程无意义而且while判断标记+notify会导致死锁

if判断标记：只有一次，会导致不该运行的线程运行，出现数据错误情况

JDK1.5新特性

将同步和锁封装成了对象，并将操作锁的隐式方式定义到了该对象中，将隐式动作变成了显示动作

创建一个锁对象

lock lock=new Reentrantlook();

void show()
{
    synchronized(obj)
    {
        code.....;           //同步代码块对于锁的操作是隐式的
    }
}

void show()
{
    lock.lock();    //获取锁
    code.....;
    lock.unlock();    //释放锁
}

通过已有的锁获取该锁上的监视器对象

Condition con=lock.newCondition( );

通过已有的锁获取2组监视器，一组监视生产者一组监视消费者

Condition producer_con=lock.newCondition();

Condition consumer_con=lock.newCondition();

Lock接口：出现替代了同步代码块或同步函数的隐式锁，操作变成了显示操作，同时更为灵活，可以一个锁上加上多组监视器

lock（）：获取锁

unlock（）：释放锁，通常需定义finally代码块中

Condition接口：出现代替了object中的wait notify notifyAll 方法，将这些监视器方法单独进行封装，变成condition监视器对象，可以任意锁进行组合。

await（）；

signal（）；

signalAll（）；

wait和sleep区别？

//sleep和wait区别
class Demo
{
	void show()
	{
		synchronized(this)
		{
			wait();//t0 t1 t2
		}
	}
	void method()
	{
		synchronized(this)
		{
			//wait();
			notifyAll();
		}//t4
	}
}
class 
{
	public static void main(String[] args)
}

1、wait可以指定时间也可以不指定

sleep必须指定时间

2、在同步时，对CPU的执行权和锁的处理不同

wait：释放执行权，释放锁

sleep：释放执行权，不释放锁