JAVA多线程 <五>等待唤醒机制

最新推荐文章于 2021-12-09 13:34:11 发布

秀才杀猪

最新推荐文章于 2021-12-09 13:34:11 发布

阅读量367

点赞数

分类专栏： Java

Java 专栏收录该内容

29 篇文章 0 订阅

订阅专栏

转载自：http://blog.csdn.net/watermusicyes/article/details/8804530

在开始讲解等待唤醒机制之前，有必要搞清一个概念——

线程之间的通信：

多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。通过一定的手段使各个线程能有效的利用资源。而这种手段即—— 等待唤醒机制。

等待唤醒机制所涉及到的方法：

wait（） :等待，将正在执行的线程释放其执行资格和执行权，并存储到线程池中。

notify（）：唤醒，唤醒线程池中被wait（）的线程，一次唤醒一个，而且是任意的。

notifyAll（）：唤醒全部：可以将线程池中的所有wait() 线程都唤醒。

其实，所谓唤醒的意思就是让线程池中的线程具备执行资格。必须注意的是，这些方法都是在同步中才有效。同时这些方法在使用时必须标明所属锁，这样才可以明确出这些方法操作的到底是哪个锁上的线程。

仔细查看JavaAPI之后，发现这些方法并不定义在 Thread中，也没定义在Runnable接口中，却被定义在了Object类中，为什么这些操作线程的方法定义在Object类中？
因为这些方法在使用时，必须要标明所属的锁，而锁又可以是任意对象。能被任意对象调用的方法一定定义在Object类中。

接下里，我们先从一个简单的示例入手:

如上图说示，输入线程想Resource中输入name ,sex , 输出线程从资源中输出，先要完成的任务是：

1. 当input发现Resource中没有数据时，开始输入，输入完成后，叫output来输出。如果发现有数据，就wait();

2. 当output发现Resource中没有数据时，就wait() ；当发现有数据时，就输出，然后，叫醒input来输入数据。

这个问题的关键在于，如何来做到交替进行。

下面看具体的代码实现：

public class Resource {
	private String name ;
	private String sex;
	private boolean flag = false;
	
	public synchronized void set(String name , String sex){
		
		if(flag)
			try {
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			//设置成员变量
			this.name = name;
			this.sex = sex;
			//设置之后，Resource中有值，将标记该为 true ,
			flag = true;
			//唤醒output
			this.notify();	
	}
	public synchronized void out(){
		if(!flag)
			try {
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}	
		//输出线程将数据输出
		System.out.println("The name is : " + name + " &&  The sex is : " + sex);
		//改变标记，以便输入线程输入数据
		flag = false;		
		//唤醒input，进行数据输入
		this.notify();	
	}

}

public class Input implements Runnable {

	private Resource r;
	public Input(Resource r){
		this.r = r;
	}
	
	@Override
	public void run() {
		int count = 0 ; 
		while(true){
			if(count == 0){
				r.set("Tom", "man");
			}else{
				r.set("Lily", "woman");
			}
			//在连个数据之间进行切换。
			count = (count + 1)%2;
		}
	}

}

public class Output implements Runnable {

	private Resource r ;
	public Output(Resource r ){
		this.r = r;
	}
	@Override
	public void run() {
		while(true){
			r.out();
		}

	}
}

public class ResourceDemo {

	public static void main(String[] args) {
		//资源对象
		Resource r = new Resource();
		//任务对象
		Input in = new Input(r);
		Output out = new Output(r);
		//线程对象
		Thread t1 = new Thread(in);
		Thread t2 = new Thread(out);
		//开启线程
		t1.start();
		t2.start();		
	}
}

在这个例子中，我们应用了等待唤醒机制，这是最简单的应用，下面我们来看看等待唤醒机制的经典问题：生产者，消费者问题！

当然也是，从最简单的问题开始看起：即单个消费者，生产者。这个例子和上个例子极其相似，因此不再赘述。接下来，主要谈一下，多生产者，多消费者的情形。

看下例子代码：

public class Resource {
	private String name;
	private int count = 1;
	private boolean flag ;
	
	public synchronized void set(String name){
		if(flag){
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
			this.name = name + count;
			count++;
			
			System.out.println(Thread.currentThread().getName() 
						+ "The producer name is :++++++++++++++ " + this.name);
			
			flag = true;
			
			this.notify();
			
	}
	
	public synchronized void out(){
		if(!flag){
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}	
		System.out.println(Thread.currentThread().getName() + 
				 "The consumer name is : ---------------------------" + this.name);
		flag = false;
		
		this.notify();
		
	}

}

public class Producer implements Runnable {

	private Resource r;
	public Producer(Resource r){
		this.r = r;
	}
	@Override
	public void run() {

		while(true){
			r.set("馒头");
		}
		
	}
}

public class Consumer implements Runnable {

	private Resource r;
	public Consumer(Resource r ){
		this.r = r;
	}
	@Override
	public void run() {

		while(true){
			r.out();
		}		
	}
}

public class ProConDemo {

	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();
	}

}

发现：生产者生产的商品没有被消费就生产了新的商品。

经过分析，发现，产生这种状况的根源是：

1，本方唤醒了本方。

2，被唤醒的本方没有判断标记。

为此，我们要做的改进是——将if 判断改为 while 标记，保证，每次被wait的线程在醒了之后，都得再次判断标记。进过修改，再次运行之后，会发现新的问题又来了，产生了死锁。经过分析，这个问题的根源在于，本方唤醒了本方，被唤醒的本方判断标记后，发现，标记不成立，就继续等待，因此，再也没有活着的线程。为此，我们需要唤醒，所有的线程，就用到了 notifyAll() 。将线程池中，所有等待的线程都叫醒。

经过修改后的代码成功的解决了上述的问题。

修改后的代码为：

public class Resource {
	private String name;
	private int count = 1;
	private boolean flag ;
	
	public synchronized void set(String name){
		//用while 确保线程醒了后再次，判断标记。
		while(flag){
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
			this.name = name + count;
			count++;
			
			System.out.println(Thread.currentThread().getName() 
						+ "The producer name is :++++++++++++++ " + this.name);
			
			flag = true;
			//唤醒所有被等待的线程
			this.notifyAll();
			
	}
	
	public synchronized void out(){
		//用while 确保线程醒了后再次，判断标记。
		while(!flag){
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}	
		System.out.println(Thread.currentThread().getName() + 
				 "The consumer name is : ---------------------------" + this.name);
		flag = false;
		//唤醒所有被等待的线程
		this.notifyAll();
		
	}
}

使用JDK的1.5版本以后可以解决一个对象只能有一个锁的问题：

<pre name="code" class="java">package thread_Demo;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class Resoucen
{
    private String name;
    private int num;
   public  boolean flag = false;
   private final Lock lock =  new ReentrantLock();
   private Condition con = lock.newCondition();
   public  void set(String name, int num)
    {
      // synchronized (this) {
           lock.lock();
           while(flag)
           {
               try
               {
                  con.await();
               } catch (InterruptedException e){}
           }
                this.name = name;
                this.num = num;
               con.signal();
                flag = true; 
                lock.unlock();
 
        //}
    }
    public void out()
    {
        //synchronized (this) {
            lock.lock();
            while(!flag)
            try
            {
                con.await();
            }catch(InterruptedException e){}
            System.out.println(this.name + "......new...." + this.num);            
            con.signal();
            flag = false;
            lock.unlock();
       // }
    }
}

class Inputn implements Runnable
{
    private Resoucen r;
   Inputn( Resoucen r)
    {
        this.r =  r;
    }
    public void run()
    {

            int count = 0;
            while(true)
            {
                    if(count % 2 == 0)
                    {
                        r.set("小米", 19);
                    }
                    else
                    {
                        r.set("小名", 20);
                        
                    }
                   ++count;
            }
    }
}
 class Outputn implements Runnable
 {
     private Resoucen r;
     Outputn( Resoucen r)
      {
          this.r =  r;
      }
     public void run()
     {
         while(true)
         {
             r.out();
         }
     }
}
public class NewProduceConsumerDemo {

    /**
     * 本程序掩饰多线程的停止等待机制  使用的是JDK的1.5版本以后的Condition和ReentrantLock
     */
    public static void main(String[] args) {
        Resoucen r = new Resoucen();
        Inputn in = new Inputn(r);
        Outputn ou = new Outputn(r);
        new Thread(in).start();
        new Thread(ou).start();
        
    }

}

秀才杀猪

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA多线程 <五>等待唤醒机制

转载自：http://blog.csdn.net/watermusicyes/article/details/8804530在开始讲解等待唤醒机制之前，有必要搞清一个概念——线程之间的通信：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。通过一定的手段使各个线程能有效的利用资源。而这种手段即—— 等待唤醒机制。等待唤醒机制所涉及到的方法：
复制链接

扫一扫

专栏目录