多线程间通信——生产者消费者问题

多线程间通信——生产者消费者问题

生产和消费同时进行，需要多线程。但是执行的任务不相同，处理的资源却是相同的：线程间的通信。

1、存在的问题及解决

期望生产一个商品就被消费掉，再生产下一个商品。

/**
 * 案例：期望生产一个商品就被消费掉，再生产下一个商品。
 */
//1、描述资源
class Resource{
    private String name;
    private int count=1;
    public Object lock=new Object();
    public void set(String name) throws InterruptedException {
        //给成员变量赋值并加上编号
        this.name = name+count;
        //编号自增
        count++;
        //打印生产了哪个商品
        Thread.sleep(500);
        System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
    }
    
    public void out() {
        System.out.println(Thread.currentThread().getName()+"...消费者.."+this.name);
    }
}

//2、描述生产者
class Producer implements Runnable{
    private Resource r;
    public Producer(Resource r){
        this.r=r;
    }
    @Override
    public void run() {
        while(true) {
                try {
                    r.set("面包");
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }        
        }
    }    
}
//3、描述消费者
class Consumer implements Runnable{
    private Resource r;
    public Consumer(Resource r){
        this.r=r;
    }
    @Override
    public void run() {
        while(true) {
                r.out();
        }
    }    
}

public class ThreadMain {
    public static void main(String[] args) {
        //1、创建资源对象
        Resource r=new Resource();
        //2、创建线程任务
        Producer p=new Producer(r);
        Consumer c=new Consumer(r);
        //3、创建线程对象
        Thread t1=new Thread(p);
        Thread t2=new Thread(c);
        
        t1.start();
        t2.start();
    }
}

出现的问题;

问题一：消费早期商品。使用同步函数：将set方法和out方法加上synchronized关键字，问题解决。

/**
 * 案例：期望生产一个商品就被消费掉，再生产下一个商品。
 * 问题一：消费早期商品。使用同步函数：将set方法和out方法加上synchronized关键字，问题解决。
 * 问题二：同一个商品重复消费，疯狂生产和疯狂消费。
 *
 */
//1、描述资源
class Resource{
    private String name;
    private int count=1;
    public Object lock=new Object();
    public synchronized void set(String name) throws InterruptedException {
        //给成员变量赋值并加上编号
        this.name = name+count;
        //编号自增
        count++;
        //打印生产了哪个商品
        Thread.sleep(500);
        System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
    }
    
    public synchronized void out() {
        System.out.println(Thread.currentThread().getName()+"...消费者.."+this.name);
    }
}

//2、描述生产者
class Producer implements Runnable{
    private Resource r;
    public Producer(Resource r){
        this.r=r;
    }
    @Override
    public void run() {
        while(true) {
                try {
                    r.set("面包");
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }        
        }
    }    
}
//3、描述消费者
class Consumer implements Runnable{
    private Resource r;
    public Consumer(Resource r){
        this.r=r;
    }
    @Override
    public void run() {
        while(true) {
                r.out();
        }
    }    
}

public class ThreadMain {
    public static void main(String[] args) {
        //1、创建资源对象
        Resource r=new Resource();
        //2、创建线程任务
        Producer p=new Producer(r);
        Consumer c=new Consumer(r);
        //3、创建线程对象
        Thread t1=new Thread(p);
        Thread t2=new Thread(c);
        
        t1.start();
        t2.start();
    }
}

问题二：同一个商品重复消费，疯狂生产和疯狂消费。

分析：生产者什么时候生产呢？当容器中没有面包时，就生产，否则不生产；

消费者什么时候消费呢？当容器中有面包时，就消费，否则不消费。

生产者生产了商品后，通知消费者来消费，这时的生产者应该处于等待状态；

消费者消费了商品后，通知生产者生产，这时消费者应该处于等待状态。

等待：wait();　　通知：notify();

以下代码中标红的为增加修改的部分。

/**
 * 案例：期望生产一个商品就被消费掉，再生产下一个商品。
 */
//1、描述资源
class Resource{
    private String name;
    private int count=1;
 8     //定义标记
 9     private boolean flag=false;
    public synchronized void set(String name) {
11         if(flag) {
12             try {wait();} catch (InterruptedException e) {}
13         }
        //给成员变量赋值并加上编号
        this.name = name+count;
        //编号自增
        count++;
        //打印生产了哪个商品
        System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
20         flag=true;
21         //唤醒消费者
22         notify();
    }
    
    public synchronized void out() {
26         if(!flag) {
27             try {wait();} catch (InterruptedException e) {}
28         }
        System.out.println(Thread.currentThread().getName()+"...消费者.."+this.name);
30         flag=false;
31         //唤醒生产者
32         notify();
    }
}

//2、描述生产者
class Producer implements Runnable{
    private Resource r;
    public Producer(Resource r){
        this.r=r;
    }
    @Override
    public void run() {
        while(true) {
                r.set("面包");        
        }
    }    
}
//3、描述消费者
class Consumer implements Runnable{
    private Resource r;
    public Consumer(Resource r){
        this.r=r;
    }
    @Override
    public void run() {
        while(true) {
                r.out();
        }
    }    
}

public class ThreadMain2 {
    public static void main(String[] args) {
        //1、创建资源对象
        Resource r=new Resource();
        //2、创建线程任务
        Producer p=new Producer(r);
        Consumer c=new Consumer(r);
        //3、创建线程对象
        Thread t1=new Thread(p);
        Thread t2=new Thread(c);
        
        t1.start();
        t2.start();
    }
}

2、等待唤醒机制

wait():　会让线程处于等待状态，其实就是将线程临时存储到了线程池中。
　　　　当前线程必须拥有此对象的监视器（锁），否则抛出java.lang.IllegalMonitorStateException

notify():　会唤醒线程池中任意一个等待的线程。

notifyAll(): 会唤醒线程池中所有的等待的线程。

 这些方法必须使用在同步中，因为必须要标识wait、notify等方法所属的锁。同一个锁上的notify，只能唤醒改锁上wait的线程。默认是this.wait();this.notify();this.notifyAll()。

 为什么这些方法定义在Object类中，而不是Thread类中呢？

因为这些方法必须标识所属的锁，而锁可以是任意对象，任意对象可以调用的方法必然是Object类中的方法。

 3、多生产多消费问题及解决方案

/**
 * 案例：多生产多消费问题
 * 问题一：生产了商品没有被消费，同一个商品被消费多次
 * 产生问题原因：被唤醒的线程没有判断标记，造成问题一的产生。
 * 解决：将if判断改为while.只要是多生产，必须是while判断条件。
 * 
 * 问题二：while判断后死锁
 * 原因：生产方唤醒了生产方的线程。本方唤醒了本方。
 * 解决方法：希望本方唤醒对方。没有对应方法，则唤醒所有。
 * 但是唤醒所有效率有点低。
 */

//1、描述资源
class Resource{
    private String name;
    private int count=1;
    //定义标记
    private boolean flag=false;
    public synchronized void set(String name) {//t1,t2
        while(flag) {
            try {wait();} catch (InterruptedException e) {}
        }
        //给成员变量赋值并加上编号
        this.name = name+count;
        //编号自增
        count++;
        //打印生产了哪个商品
        System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
        flag=true;
        //唤醒消费者
        notifyAll();
    }
    
    public synchronized void out() {//t3,t4
        while(!flag) {
            try {wait();} catch (InterruptedException e) {}
        }
        System.out.println(Thread.currentThread().getName()+"...消费者.."+this.name);
        flag=false;
        //唤醒生产者
        notifyAll();
    }
}

//2、描述生产者
class Producer implements Runnable{
    private Resource r;
    public Producer(Resource r){
        this.r=r;
    }
    @Override
    public void run() {
        while(true) {
                r.set("面包");        
        }
    }    
}
//3、描述消费者
class Consumer implements Runnable{
    private Resource r;
    public Consumer(Resource r){
        this.r=r;
    }
    @Override
    public void run() {
        while(true) {
                r.out();
        }
    }    
}

public class ThreadMain3 {
    public static void main(String[] args) {
        //1、创建资源对象
        Resource r=new Resource();
        //2、创建线程任务
        Producer p=new Producer(r);
        Consumer c=new Consumer(r);
        //3、创建线程对象
        Thread t1=new Thread(p);
        Thread t2=new Thread(c);
        Thread t3=new Thread(p);
        Thread t4=new Thread(c);
        
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

4、多线程间通信-jdk1.5-Lock接口

jdk1.5以后提供多生产多消费的解决方案。在java.util.concurrent.locks软件包中提供了解决方案。

Lock接口：Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。此实现允许更灵活的结构，可以具有差别很大的属性，可以支持多个相关的 Condition 对象。

随着灵活性的增加，也带来了更多的责任。不使用块结构锁就失去了使用 synchronized 方法和语句时会出现的锁自动释放功能。在大多数情况下，应该使用以下语句：

     Lock l = ...; 
     l.lock();
     try {
         // access the resource protected by this lock
     } finally {
         l.unlock();
     }

Lock方法：

void lock()	获取锁。
void lockInterruptibly()	如果当前线程未被中断，则获取锁。
Condition newCondition()	返回绑定到此 Lock 实例的新 Condition 实例。
boolean tryLock()	仅在调用时锁为空闲状态才获取该锁。
boolean tryLock(long time, TimeUnit unit)	如果锁在给定的等待时间内空闲，并且当前线程未被中断，则获取锁。
void unlock()	释放锁

 多生产多消费的效率问题解决： 

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

/**
    jdk1.5将原有的监视器方法wait(),notify(),notifyAll封装到Condition对象中。
    Condition对象的出现其实是替代了Object中的监视器方法。
    await();    signal();    signalAll();
    旧版中唤醒所有的方法效率低。
    jdk1.5以后，可以在一个lock锁上加上多个监视器对象。
 */

//1、描述资源
class Resource{
    private String name;
    private int count=1;
    //定义一个锁对象
    private Lock lock=new ReentrantLock();
    //获取锁上的Condition对象，为了解决本方唤醒对象问题，可以一个锁创建两个监视器对象。
    private Condition consu=lock.newCondition();//获取lock上的监视器方法,负责消费
    private Condition produ=lock.newCondition();//获取lock上的监视器方法，负责生产
    
    //定义标记
    private boolean flag=false;

    public void set(String name) {//t1,t2
        //获取锁
        lock.lock();
        try {
            while(flag) {
                try {produ.await();} catch (InterruptedException e) {}
            }
            //给成员变量赋值并加上编号
            this.name = name+count;
            //编号自增
            count++;
            //打印生产了哪个商品
            System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
            flag=true;
            //唤醒消费者
            consu.signal();
        }finally {
            lock.unlock();//一定要执行
        }

    }

    public void out() {//t3,t4
        //获取锁
        lock.lock();
        try {
            while(!flag) {
                try {consu.await();} catch (InterruptedException e) {}
            }
            System.out.println(Thread.currentThread().getName()+"...消费者.."+this.name);
            flag=false;
            //唤醒生产者
            produ.signal();
        }finally{
            lock.unlock();//一定要执行
        }
    }
}

//2、描述生产者
class Producer implements Runnable{
    private Resource r;
    public Producer(Resource r){
        this.r=r;
    }
    @Override
    public void run() {
        while(true) {
            r.set("面包");        
        }
    }    
}
//3、描述消费者
class Consumer implements Runnable{
    private Resource r;
    public Consumer(Resource r){
        this.r=r;
    }
    @Override
    public void run() {
        while(true) {
            r.out();
        }
    }    
}

public class ThreadMain4 {
    public static void main(String[] args) {
        //1、创建资源对象
        Resource r=new Resource();
        //2、创建线程任务
        Producer p=new Producer(r);
        Consumer c=new Consumer(r);
        //3、创建线程对象
        Thread t1=new Thread(p);
        Thread t2=new Thread(p);
        Thread t3=new Thread(c);
        Thread t4=new Thread(c);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}