Java 多线程之并发协做生产者消费者设计模式 JDK1.5.0 + 升级优化版

转载请注明出处：blog.csdn.net/linglongxin…

---

上一篇[Java多线程之并发协做生产者消费者设计模式]已经讲述了在Java的多线程中，如何处理并发安全的生产者消费者设计模式，不了解的能够先看看上一篇的内容

#上一篇中的效率和优化问题

• 在上一篇中生产者消费者设计模式中最后为了避免产生相似于“死锁”，就是多线程所有wait()致使程序没法向下继续运行的状况，咱们采用了notifyAll()这个方法，那么有什么问题呢？
• 效率问题，notifyAll()方法是将在执行了wait()方法后的全部等待线程都唤醒了，那么也就是说，即唤醒了生产者线程也唤醒了消费者线程
• 优化方案：咱们没有必要把你们都唤醒，只须要让生产者线程唤醒消费者线程，消费者线程唤醒生产者线程便可。

#jdk1.5的对多线程并发安全的新解决方案

• jdk1.5之后将同步和锁封装成了对象。并将操做锁的隐式方式定义到了该对象中，将隐式动做变成了显示动做。
• Lock接口： 出现替代了同步代码块或者同步函数。将同步的隐式锁操做变成现实锁操做。同时更为灵活。能够一个锁上加上多组监视器。
• lock():获取锁。
• unlock():释放锁，一般须要定义finally代码块中。
• Condition接口：出现替代了Object中的wait notify notifyAll方法。将这些监视器方法单独进行了封装，变成Condition监视器对象。能够任意锁进行组合。
• await();线程等待—>等同于wait();【监视器的方法】
• signal();唤醒线程——>等同于notify();【监视器的方法】
• signalAll();唤醒所有等待中的线程——>等同于notifyAll();【监视器的方法】

#最终通过优化的代码

• Resource.java

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

/** * Created by yuandl on 2016-10-12. * 要生产的资源 */
public class Resource {
    private int number = 0;//资源编号
    private boolean flag = false;//资源标记 时候有资源

    /* 建立一个锁对象。*/
    private Lock lock = new ReentrantLock();//锁
    /*经过已有的锁获取该锁上的监视器对象。经过已有的锁获取两组监视器，一组监视生产者，一组监视消费者。*/
    private Condition condition_consumer = lock.newCondition();//消费者对锁的监视器
    private Condition condition_producer = lock.newCondition();//生产者对锁的监视器

    public void create() {
        lock.lock();
        try {
            while (flag) {
                condition_producer.await();
            }
            number++;
            System.out.println("生产者--------------" + number);
            flag = true;
            condition_consumer.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void destroy() {
        lock.lock();
        try {
            while (!flag) {
                condition_consumer.await();
            }
            System.out.println("消费者***" + number);
            flag = false;
            condition_producer.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}复制代码

• Producer.java

/** * Created by yuandl on 2016-10-12. * 生产者 */
public class Producer implements Runnable {
    private Resource resource;

    public Producer(Resource resource) {
        this.resource = resource;
    }

    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            resource.create();
        }
    }
}复制代码

• Consumer.java

/** * Created by yuandl on 2016-10-12. * 消费者 */
public class Consumer implements Runnable {
    private Resource resource;

    public Consumer(Resource resource) {
        this.resource = resource;
    }

    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            resource.destroy();
        }
    }
}复制代码

• MainTest.java

package thread.produceconsumer2;

/** * Created by yuandl on 2016-10-12. */
public class MainTest {
    public static void main(String args[]) {
        Resource resource = new Resource();
        new Thread(new Producer(resource)).start();
        new Thread(new Producer(resource)).start();
        new Thread(new Consumer(resource)).start();
        new Thread(new Consumer(resource)).start();
    }
}复制代码

• 打印结果

生产者--------------381
消费者***381
生产者--------------382
消费者***382
生产者--------------383
消费者***383
生产者--------------384
消费者***384
生产者--------------385
消费者***385
生产者--------------386
消费者***386
生产者--------------387
消费者***387
生产者--------------388
消费者***388
生产者--------------389
消费者***389
生产者--------------390
消费者***390
生产者--------------391
消费者***391复制代码