黑马程序员-Java基础-多线程间通讯

--------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

* 线程间通讯：
* 其实就是多线程在操作同一个资源，但是操作的动作不同。
* 
* wait:
* notify:
* notifyAll:
*都使用在同步中，因为要对持有监视器的线程操作，只有同步才有锁。

       * Lock是从1.5之后的新特性，
       * 提供了显式的锁机制，以及显示的锁对象 上的等待唤醒操作机制。
        * 一个锁可以对应多个condition对象，以前锁只能对应一个对象，容易产生死锁。
 
       * 将同步中的synchronized替换成了实现Lock操作。
       *  condition对象中有await()，signal,signalAll方法
       *  将Object中的wait,notify，notifyAll替换。
       * 该对象可以Lock锁进行获取。

* stop方法已经过时。
* 停止线程的原理：
* 停止线程，只要停止run结束。
* 开启多线程运行，运行代码通常是循环结构。
* 只要控制循环，就可以让run方法结束。也就是线程结束。
* 
* 特殊情况：
* 当线程处于冻结状态，就不会读取到标记，那么线程就不会结束。
* 当没有指定的方式让冻结的线程恢复到运行状态时，这时需要对冻结进行清除。
* 强制让线程恢复到运行状态中来，这样可以操作标记让线程结束。
*
* Thread类提供了方法interrupt（），清除线程的冻结状态，然后利用标记flag结束线程。。

*为什么这些操作线程的方法要定义在Object类中呢？
*因为这些方法在操作同步中线程时，都必须要标识它们所操作线程中的锁。
*只有同一个锁上的被等待线程，可以被锁上notify唤醒。不可以对不同锁中的线程进行唤醒。
*也就是说，等待和唤醒必须是同一个锁。而锁可以是任意对象，所以可以被任意对象的方法定义在Object类中。

        

          下面一生产者和消费者的例子说明线程间通讯。

         方式一：使用Synchronized方式实现：代码如下：

         

package com.itheima.day12;
/**
 * 生产者-消费者举例
 * notifyAll适合于多个生产者和多个消费者的情况。实际中较为通用的方式。
 * 对于多个生产者和消费者，为什么要定义while判断标记呢？
 * 原因：让被唤醒的线程再一次判断标记。
 * 为什么定义notifyAll
 * 因为需呀唤醒对方线程，如果只用notify，容易出现只唤醒本方线程的情况，导致程序中的所有线程都等待。
 */
public 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.start();
		t2.start();
		t3.start();
		t4.start();
	}

}
class Resource
{
   private String  name;
   private int count = 1;
   private boolean flag = false;
   public synchronized void set(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;
	   this.notifyAll();
   }
   public synchronized void out()
   {
	   while(!flag)
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
	   System.out.println(Thread.currentThread().getName()+"-消费者-"+this.name);
	   flag = false;
	   this.notifyAll();
   }
}
class Producer implements Runnable
{
    private Resource re;
    Producer(Resource re)
    {
    	this.re = re;
    }
	public void run() 
	{
		while(true)
		{
		  re.set("+商品+");
		}
	}
}
class Consumer implements Runnable
{
    private Resource re;
    Consumer(Resource re)
    {
    	this.re = re;
    }
	public void run() 
	{
		while(true)
		{
		  re.out();
		}
	}
	
}
/*适合于消费者一个，生产者也是一个的情况
public 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();

}

}
class Resource
{
	private String  name;
	private int count = 1;
	private boolean flag = false;
	public synchronized void set(String name)
	{
	   if(flag)
		try {
			wait();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	   this.name = name+"--"+count++;
	   System.out.println(Thread.currentThread().getName()+"-生产者------"+this.name);
	   flag = true;
	   notify();
}
public synchronized void out()
{
   if(!flag)
		try {
			wait();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	   System.out.println(Thread.currentThread().getName()+"-消费者-"+this.name);
	   flag = false;
	   notify();
}
class Producer implements Runnable
{
	private Resource re;
	Producer(Resource re)
	{
		this.re = re;
	}
	public void run() 
	{
		while(true)
		{
		  re.set("+商品+");
		}
	}
}
class Consumer implements Runnable
{
	private Resource re;
	Consumer(Resource re)
	{
		this.re = re;
	}
	public void run() 
	{
		while(true)
		{
		  re.out();
		}
	}
}
*/

实现方式二：Lock锁实现线程间通讯

package com.itheima.day12;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 生产者-消费者举例
 * 
 * Lock是从1.5之后的新特性，
 * 提供了显式的锁机制，以及显示的锁对象 上的等待唤醒操作机制。
 * 一个锁可以对应多个condition对象，以前锁只能对应一个对象，容易产生死锁。	
 * 
 * 将同步中的synchronized替换成了实现Lock操作。
 *  condition对象中有await()，signal,signalAll方法
 *  将Object中的wait,notify，notifyAll替换。
 * 该对象可以Lock锁进行获取。
 * 在该示例中，实现了本方只唤醒对方的操作。
 *
 */
public class LockProducerConsumerDemo {

	public static void main(String[] args)
	{

		Resource1 r = new Resource1();
		Producer1 pro = new Producer1(r);
		Consumer1 con = new Consumer1(r);
		Thread t1 = new Thread(pro);
		Thread t2 = new Thread(pro);
		Thread t3 = new Thread(con);
		Thread t4 = new Thread(con);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}
class Resource1
{
   private String  name;
   private int count = 1;
   private boolean flag = false;
   private Lock lk = new ReentrantLock();
   private Condition condition_pro = lk.newCondition();
   // 一个锁可以对应多个condition对象。
   private Condition condition_con = lk.newCondition();
   public  void set(String name) throws InterruptedException
   {
	   lk.lock();
	   try{
		   while(flag)
			   condition_pro.await();//t1 t2
		   this.name = name+"--"+count++;
		   System.out.println(Thread.currentThread().getName()+"-生产者------"+this.name);
		   flag = true;
		   condition_con.signal();
	   }finally
	   {
	   lk.unlock();//释放锁的动作一定要执行，防止await产生异常造成死锁。
	   }
   }
   //t3 t4
   public  void out() throws InterruptedException
   {
	   lk.lock();
	   try
	   {
		   while(!flag)
			   condition_con.await();
		   System.out.println(Thread.currentThread().getName()+"-消费者-"+this.name);
		   flag = false;
		   condition_pro.signal();	
	   }
	   finally
	   {
		   lk.unlock();
	   }
   }
}
class Producer1 implements Runnable
{
    private Resource1 re;
    Producer1(Resource1 re)
    {
    	this.re = re;
    }
	public void run() 
	{
		while(true)
		{
		  try {
			re.set("+商品+");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		}
	}
}
class Consumer1 implements Runnable
{
    private Resource1 re;
    Consumer1(Resource1 re)
    {
    	this.re = re;
    }
	public void run() 
	{
		while(true)
		{
		  try {
			re.out();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		}
	}
}

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------