黑马程序员——多线程2

------- android培训、java培训、期待与您交流！ ----------

接着上回的来

线程间通信涉及的方法

多个线程在处理统一资源，但是任务却不同，这时候就需要线程间通信。
等待/唤醒机制涉及的方法：
1. wait()：让线程处于冻结状态，被wait的线程会被存储到线程池中。
2. notify()：唤醒线程池中的一个线程。
3. notifyAll ()：唤醒线程池中的所有线程。

P.S.
1、这些方法都必须定义在同步中，因为这些方法是用于操作线程状态的方法。
2、必须要明确到底操作的是哪个锁上的线程！
3、wait和sleep区别？
1）wait可以指定时间也可以不指定。sleep必须指定时间。
2）在同步中时，对CPU的执行权和锁的处理不同。
3）wait：释放执行权，释放锁。
      sleep：释放执行权，不释放锁。

练习：编写一个多线程程序，模拟2个生产者生产产品，2个消费者消费产品。2个生产者不停的生产商品2个消费者不停的消费产品。

class Resource
{
	private String name;//产品名称
	private int count=0;//编号
	private boolean flag=false;//是否有资源的标记位，初始无资源
	public synchronized void setName(String name)
	{
		while(flag)
		{
			try
			{
				wait();//若有资源生产者等待
			}
			catch (InterruptedException e)
			{
				e.printStackTrace();
			}	
		}
		this.name=name+(++count);//偷个懒，名称编号放一起了
		System.out.println(Thread.currentThread().getName()+"生产者--生产"+this.name);
		flag=true;//产生资源
		notifyAll();//唤醒等待线程
	}
	public synchronized void out()
	{
		while(!flag)
		{
			try
			{
				wait();//没有资源时消费者等待
			}
			catch (InterruptedException e)
			{
				e.printStackTrace();
			}
		}
		System.out.println(Thread.currentThread().getName()+"消费者--消费"+name);
		flag=false;
		notifyAll();
	}
}

class Producer implements Runnable
{
	private Resource r;//将资源类封装进生产者中
	Producer(Resource r)
	{
		this.r=r;
	}
	public void run()
	{
		while(true)
		{
			r.setName("火柴");
		}
	}
}

class Consumer implements Runnable
{
	private Resource r;
	Consumer(Resource r)
	{
		this.r=r;
	}
	public void run()
	{
		while(true)
		{
			r.out();
		}
	}
}
class ProducerDemo 
{
	public static void main(String[] args) 
	{
		Resource r=new Resource();
		Thread t1=new Thread(new Producer(r));
		Thread t2=new Thread(new Producer(r));
		Thread t3=new Thread(new Consumer(r));
		Thread t4=new Thread(new Consumer(r));
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

P.S.

在setName和out中若使用if判断标记，等待线程唤醒后不再判断标记，会导致不该运行的线程运行了，出现了数据错误的情况。故修改成while判断标记，线程获取CPU执行权及锁后，将重新判断是否具备运行条件。而notify方法只能唤醒一个线程，如果本方唤醒了本方，没有意义。while判断标记+notify会导致死锁。notifyAll解决了本方线程一定要唤醒对方线程的问题。

JDK1.5新特性

同步代码块就是对于锁的操作是隐式的。
JDK1.5以后将同步和锁封装成了对象，并将操作锁的隐式方式定义到了该对象中，将隐式动作变成了
显示动作。
Lock接口：出现替代了同步代码块或者同步函数，将同步的隐式操作变成显示锁操作。同时更为灵
活，可以一个锁上加上多组监视器。
lock()：获取锁。
unlock()：释放锁，为了防止异常出现，导致锁无法被关闭，所以锁的关闭动作要放在finally中。
Condition接口：出现替代了Object中的wait、notify、notifyAl l 方法。将这些监视器方法单独进行了
封装，变成Condition监视器对象，可以任意锁进行组合。
Condition接口中的await方法对应于Object中的wait方法。
Condition接口中的signal 方法对应于Object中的notify方法。
Condition接口中的signalAll 方法对应于Object中的notifyAll 方法。

使用锁的形式改进上面的练习

import java.util.concurrent.locks.*;//莫忘导包

class Resource
{
	private String name;
	private int count;
	private boolean flag=false;//是否有商品的标记位

	private Lock lock = new ReentrantLock();//创建锁对象
	private Condition condition_pro=lock.newCondition();//生产者监视器
	private Condition condition_con=lock.newCondition();//消费者监视器（与生产者监视器同锁）
	public void set(String name)throws InterruptedException
	{
		lock.lock();
		try
		{
			while(flag)
				condition_pro.await();
			this.name = name+"--"+count++;

			System.out.println("生产者.."+Thread.currentThread().getName()+"...生产"+this.name);
			flag = true;
			condition_con.signal();//只唤醒消费者
		}
		finally
		{
			lock.unlock();//解锁动作一定执行
		}
	}
	public void out()throws InterruptedException
	{
		lock.lock();
		try
		{
			while(!flag)
				condition_con.await();
			System.out.println("...消费者......"+Thread.currentThread().getName()+"...消费"+this.name);
			flag = false;
			condition_pro.signal();//唤醒生产者
		}
		finally
		{
			lock.unlock();//一定执行
		}
	}
	
}

class Producer implements Runnable
{
	private Resource res;
	Producer(Resource res)
	{
		this.res=res;
	}
	public void run()
	{
		while(true)
		{
			try
			{
				res.set("+商品+");
			}
			catch (InterruptedException e)
			{
			}
		}
	}
}

class Consumer implements Runnable
{
	private Resource res;
	Consumer(Resource res)
	{
		this.res=res;
	}
	public void run()
	{
		while(true)
		{
			try
			{
				res.out();
			}
			catch (InterruptedException e)
			{
			}
		}
	}
}

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(pro);
		Thread t3 = new Thread(con);
		Thread t4 = new Thread(con);
		t1.setName("厂家A");
		t2.setName("厂家B");
		t3.setName("顾客A");
		t4.setName("顾客B");
		t1.start();
		t2.start();
		t3.start();
		t4.start();


	}
}

由此可实现本方只唤醒对方的操作~（请注意锁和监视器的创建）

守护线程

线程默认是非守护的（用户线程）。当程序中所有用户线程都已结束运行时，即使守护线程还在执行，也立即结束运行。

打个比方，就相当于公司boss没了，员工也就都黄了。

一个线程必须在运行之前设置是否为守护线程。

setDaemon(true)

线程联合

join:当线程A执行到B线程的join方法时，A就会等待，等B执行完了，A才会执行。

（其他线程不会等待）可用来临时加入线程执行。