`
mdxdjh2
  • 浏览: 12074 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

【转】生产者/消费者问题的多种Java实现方式

    博客分类：
  • JAVA
并发多线程 
阅读更多

生产者消费者问题是研究多线程程序时绕不开的经典问题之一，它描述是有一块缓冲区作为仓库，生产者可以将产品放入仓库，消费者则可以从仓库中取走产品。解决生产者/消费者问题的方法可分为两类：（1）采用某种机制保护生产者和消费者之间的同步；（2）在生产者和消费者之间建立一个管道。第一种方式有较高的效率，并且易于实现，代码的可控制性较好，属于常用的模式。第二种管道缓冲区不易控制，被传输数据对象不易于封装等，实用性不强。因此本文只介绍同步机制实现的生产者/消费者问题。

同步问题核心在于：如何保证同一资源被多个线程并发访问时的完整性。常用的同步方法是采用信号或加锁机制，保证资源在任意时刻至多被一个线程访问。Java语言在多线程编程上实现了完全对象化，提供了对同步机制的良好支持。在Java中一共有四种方法支持同步，其中前三个是同步方法，一个是管道方法。

（1）wait() / notify()方法

（2）await() / signal()方法

（3）BlockingQueue阻塞队列方法

（4）PipedInputStream / PipedOutputStream

本文只介绍最常用的前三种，第四种暂不做讨论，有兴趣的读者可以自己去网上找答案。

 

一、wait() / notify()方法

wait() / nofity()方法是基类Object的两个方法，也就意味着所有Java类都会拥有这两个方法，这样，我们就可以为任何对象实现同步机制。

wait()方法：当缓冲区已满/空时，生产者/消费者线程停止自己的执行，放弃锁，使自己处于等等状态，让其他线程执行。

notify()方法：当生产者/消费者向缓冲区放入/取出一个产品时，向其他等待的线程发出可执行的通知，同时放弃锁，使自己处于等待状态。

光看文字可能不太好理解，咱来段代码就明白了：

 

import java.util.LinkedList;  
  
/** 
 * 仓库类Storage实现缓冲区 
 */  
public class Storage  
{  
    // 仓库最大存储量  
    private final int MAX_SIZE = 100;  
    // 仓库存储的载体  
    private LinkedList<Object> list = new LinkedList<Object>();  
    // 生产num个产品  
    public void produce(int num)  
    {  
        // 同步代码段  
        synchronized (list)  
        {  
            // 如果仓库剩余容量不足  
            while (list.size() + num > MAX_SIZE)  
            {  
                System.out.println("【要生产的产品数量】:" + num + "/t【库存量】:"  
                        + list.size() + "/t暂时不能执行生产任务!");  
                try  
                {  
                    // 由于条件不满足，生产阻塞  
                    list.wait();  
                }  
                catch (InterruptedException e)  
                {  
                    e.printStackTrace();  
                }  
            }  
  
            // 生产条件满足情况下，生产num个产品  
            for (int i = 1; i <= num; ++i)  
            {  
                list.add(new Object());  
            }  
            System.out.println("【已经生产产品数】:" + num + "/t【现仓储量为】:" + list.size());  
            list.notifyAll();  
        }  
    }  
  
    // 消费num个产品  
    public void consume(int num)  
    {  
        // 同步代码段  
        synchronized (list)  
        {  
            // 如果仓库存储量不足  
            while (list.size() < num)  
            {  
                System.out.println("【要消费的产品数量】:" + num + "/t【库存量】:"  
                        + list.size() + "/t暂时不能执行生产任务!");  
                try  
                {  
                    // 由于条件不满足，消费阻塞  
                    list.wait();  
                }  
                catch (InterruptedException e)  
                {  
                    e.printStackTrace();  
                }  
            }  
            // 消费条件满足情况下，消费num个产品  
            for (int i = 1; i <= num; ++i)  
            {  
                list.remove();  
            }  
            System.out.println("【已经消费产品数】:" + num + "/t【现仓储量为】:" + list.size());  
            list.notifyAll();  
        }  
    }  
  
    // get/set方法  
    public LinkedList<Object> getList()  
    {  
        return list;  
    }  
    public void setList(LinkedList<Object> list)  
    {  
        this.list = list;  
    }  
    public int getMAX_SIZE()  
    {  
        return MAX_SIZE;  
    }  
}  
/** 
 * 生产者类Producer继承线程类Thread 
 */  
public class Producer extends Thread  
{  
    // 每次生产的产品数量  
    private int num;  
    // 所在放置的仓库  
    private Storage storage;  
    // 构造函数，设置仓库  
    public Producer(Storage storage)  
    {  
        this.storage = storage;  
    }  
    // 线程run函数  
    public void run()  
    {  
        produce(num);  
    }  
    // 调用仓库Storage的生产函数  
    public void produce(int num)  
    {  
        storage.produce(num);  
    }  
    // get/set方法  
    public int getNum()  
    {  
        return num;  
    }  
    public void setNum(int num)  
    {  
        this.num = num;  
    }  
    public Storage getStorage()  
    {  
        return storage;  
    }  
    public void setStorage(Storage storage)  
    {  
        this.storage = storage;  
    }  
}  
/** 
 * 消费者类Consumer继承线程类Thread 
 */  
public class Consumer extends Thread  
{  
    // 每次消费的产品数量  
    private int num;  
    // 所在放置的仓库  
    private Storage storage;  
    // 构造函数，设置仓库  
    public Consumer(Storage storage)  
    {  
        this.storage = storage;  
    }  
    // 线程run函数  
    public void run()  
    {  
        consume(num);  
    }  
    // 调用仓库Storage的生产函数  
    public void consume(int num)  
    {  
        storage.consume(num);  
    }  
    // get/set方法  
    public int getNum()  
    {  
        return num;  
    }  
    public void setNum(int num)  
    {  
        this.num = num;  
    }  
    public Storage getStorage()  
    {  
        return storage;  
    }  
    public void setStorage(Storage storage)  
    {  
        this.storage = storage;  
    }  
}  
/** 
 * 测试类Test 
 */  
public class Test  
{  
    public static void main(String[] args)  
    {  
        // 仓库对象  
        Storage storage = new Storage();  
  
        // 生产者对象  
        Producer p1 = new Producer(storage);  
        Producer p2 = new Producer(storage);  
        Producer p3 = new Producer(storage);  
        Producer p4 = new Producer(storage);  
        Producer p5 = new Producer(storage);  
        Producer p6 = new Producer(storage);  
        Producer p7 = new Producer(storage);  
  
        // 消费者对象  
        Consumer c1 = new Consumer(storage);  
        Consumer c2 = new Consumer(storage);  
        Consumer c3 = new Consumer(storage);  
  
        // 设置生产者产品生产数量  
        p1.setNum(10);  
        p2.setNum(10);  
        p3.setNum(10);  
        p4.setNum(10);  
        p5.setNum(10);  
        p6.setNum(10);  
        p7.setNum(80);  
  
        // 设置消费者产品消费数量  
        c1.setNum(50);  
        c2.setNum(20);  
        c3.setNum(30);  
  
        // 线程开始执行  
        c1.start();  
        c2.start();  
        c3.start();  
        p1.start();  
        p2.start();  
        p3.start();  
        p4.start();  
        p5.start();  
        p6.start();  
        p7.start();  
    }  
}  
【要消费的产品数量】:50   【库存量】:0 暂时不能执行生产任务!  
【要消费的产品数量】:30   【库存量】:0 暂时不能执行生产任务!  
【要消费的产品数量】:20   【库存量】:0 暂时不能执行生产任务!  
【已经生产产品数】:10    【现仓储量为】:10  
【要消费的产品数量】:20   【库存量】:10    暂时不能执行生产任务!  
【要消费的产品数量】:30   【库存量】:10    暂时不能执行生产任务!  
【要消费的产品数量】:50   【库存量】:10    暂时不能执行生产任务!  
【已经生产产品数】:10    【现仓储量为】:20  
【要消费的产品数量】:50   【库存量】:20    暂时不能执行生产任务!  
【要消费的产品数量】:30   【库存量】:20    暂时不能执行生产任务!  
【已经消费产品数】:20    【现仓储量为】:0  
【已经生产产品数】:10    【现仓储量为】:10  
【已经生产产品数】:10    【现仓储量为】:20  
【已经生产产品数】:80    【现仓储量为】:100  
【要生产的产品数量】:10   【库存量】:100   暂时不能执行生产任务!  
【已经消费产品数】:30    【现仓储量为】:70  
【已经消费产品数】:50    【现仓储量为】:20  
【已经生产产品数】:10    【现仓储量为】:30  
【已经生产产品数】:10    【现仓储量为】:40

看完上述代码，对wait() / notify()方法实现的同步有了了解。你可能会对Storage类中为什么要定义public void produce(int num);和public void consume(int num);方法感到不解，为什么不直接在生产者类Producer和消费者类Consumer中实现这两个方法，却要调用Storage类中的实现呢？淡定，后文会有解释。我们先往下走。

 

 

二、await() / signal()方法

在JDK5.0之后，Java提供了更加健壮的线程处理机制，包括同步、锁定、线程池等，它们可以实现更细粒度的线程控制。await()和signal()就是其中用来做同步的两种方法，它们的功能基本上和wait() / nofity()相同，完全可以取代它们，但是它们和新引入的锁定机制Lock直接挂钩，具有更大的灵活性。通过在Lock对象上调用newCondition()方法，将条件变量和一个锁对象进行绑定，进而控制并发程序访问竞争资源的安全。下面来看代码：

 

import java.util.LinkedList;  
import java.util.concurrent.locks.Condition;  
import java.util.concurrent.locks.Lock;  
import java.util.concurrent.locks.ReentrantLock;  
  
/** 
 * 仓库类Storage实现缓冲区 
 */  
public class Storage  
{  
    // 仓库最大存储量  
    private final int MAX_SIZE = 100;  
    // 仓库存储的载体  
    private LinkedList<Object> list = new LinkedList<Object>();  
    // 锁  
    private final Lock lock = new ReentrantLock();  
    // 仓库满的条件变量  
    private final Condition full = lock.newCondition();  
    // 仓库空的条件变量  
    private final Condition empty = lock.newCondition();  
    // 生产num个产品  
    public void produce(int num)  
    {  
        // 获得锁  
        lock.lock();  
        // 如果仓库剩余容量不足  
        while (list.size() + num > MAX_SIZE)  
        {  
            System.out.println("【要生产的产品数量】:" + num + "/t【库存量】:" + list.size()  
                    + "/t暂时不能执行生产任务!");  
            try  
            {  
                // 由于条件不满足，生产阻塞  
                full.await();  
            }  
            catch (InterruptedException e)  
            {  
                e.printStackTrace();  
            }  
        }  
        // 生产条件满足情况下，生产num个产品  
        for (int i = 1; i <= num; ++i)  
        {  
            list.add(new Object());  
        }  
        System.out.println("【已经生产产品数】:" + num + "/t【现仓储量为】:" + list.size())
        // 唤醒其他所有线程  
        full.signalAll();  
        empty.signalAll();  
        // 释放锁  
        lock.unlock();  
    }  
  
    // 消费num个产品  
    public void consume(int num)  
    {  
        // 获得锁  
        lock.lock();  
        // 如果仓库存储量不足  
        while (list.size() < num)  
        {  
            System.out.println("【要消费的产品数量】:" + num + "/t【库存量】:" + list.size()  
                    + "/t暂时不能执行生产任务!");  
            try  
            {  
                // 由于条件不满足，消费阻塞  
                empty.await();  
            }  
            catch (InterruptedException e)  
            {  
                e.printStackTrace();  
            }  
        }  
        // 消费条件满足情况下，消费num个产品  
        for (int i = 1; i <= num; ++i)  
        {  
            list.remove();  
        }  
        System.out.println("【已经消费产品数】:" + num + "/t【现仓储量为】:" + list.size());  
        // 唤醒其他所有线程  
        full.signalAll();  
        empty.signalAll();  
  
        // 释放锁  
        lock.unlock();  
    }  
    // set/get方法  
    public int getMAX_SIZE()  
    {  
        return MAX_SIZE;  
    }  
    public LinkedList<Object> getList()  
    {  
        return list;  
    }  
    public void setList(LinkedList<Object> list)  
    {  
        this.list = list;  
    }  
}  
【要消费的产品数量】:50   【库存量】:0 暂时不能执行生产任务!  
【要消费的产品数量】:30   【库存量】:0 暂时不能执行生产任务!  
【已经生产产品数】:10    【现仓储量为】:10  
【已经生产产品数】:10    【现仓储量为】:20  
【要消费的产品数量】:50   【库存量】:20    暂时不能执行生产任务!  
【要消费的产品数量】:30   【库存量】:20    暂时不能执行生产任务!  
【已经生产产品数】:10    【现仓储量为】:30  
【要消费的产品数量】:50   【库存量】:30    暂时不能执行生产任务!  
【已经消费产品数】:20    【现仓储量为】:10  
【已经生产产品数】:10    【现仓储量为】:20  
【要消费的产品数量】:30   【库存量】:20    暂时不能执行生产任务!  
【已经生产产品数】:80    【现仓储量为】:100  
【要生产的产品数量】:10   【库存量】:100   暂时不能执行生产任务!  
【已经消费产品数】:50    【现仓储量为】:50  
【已经生产产品数】:10    【现仓储量为】:60  
【已经消费产品数】:30    【现仓储量为】:30  
【已经生产产品数】:10    【现仓储量为】:40

只需要更新仓库类Storage的代码即可，生产者Producer、消费者Consumer、测试类Test的代码均不需要进行任何更改。这样我们就知道为神马我要在Storage类中定义public void produce(int num);和public void consume(int num);方法，并在生产者类Producer和消费者类Consumer中调用Storage类中的实现了吧。将可能发生的变化集中到一个类中，不影响原有的构架设计，同时无需修改其他业务层代码。无意之中，我们好像使用了某种设计模式，具体是啥我忘记了，啊哈哈，等我想起来再告诉大家~

 

 

三、BlockingQueue阻塞队列方法

BlockingQueue是JDK5.0的新增内容，它是一个已经在内部实现了同步的队列，实现方式采用的是我们第2种await() / signal()方法。它可以在生成对象时指定容量大小。它用于阻塞操作的是put()和take()方法。

put()方法：类似于我们上面的生产者线程，容量达到最大时，自动阻塞。

take()方法：类似于我们上面的消费者线程，容量为0时，自动阻塞。

关于BlockingQueue的内容网上有很多，大家可以自己搜，我在这不多介绍。下面直接看代码，跟以往一样，我们只需要更改仓库类Storage的代码即可：

 

import java.util.concurrent.LinkedBlockingQueue;  
  
/** 
 * 仓库类Storage实现缓冲区 
 */  
public class Storage  
{  
    // 仓库最大存储量  
    private final int MAX_SIZE = 100;  
  
    // 仓库存储的载体  
    private LinkedBlockingQueue<Object> list = new LinkedBlockingQueue<Object>(  
            100);  
    // 生产num个产品  
    public void produce(int num)  
    {  
        // 如果仓库剩余容量为0  
        if (list.size() == MAX_SIZE)  
        {  
            System.out.println("【库存量】:" + MAX_SIZE + "/t暂时不能执行生产任务!");  
        }  
        // 生产条件满足情况下，生产num个产品  
        for (int i = 1; i <= num; ++i)  
        {  
            try  
            {  
                // 放入产品，自动阻塞  
                list.put(new Object());  
            }  
            catch (InterruptedException e)  
            {  
                e.printStackTrace();  
            }  
  
            System.out.println("【现仓储量为】:" + list.size());  
        }  
    }  
    // 消费num个产品  
    public void consume(int num)  
    {  
        // 如果仓库存储量不足  
        if (list.size() == 0)  
        {  
            System.out.println("【库存量】:0/t暂时不能执行生产任务!");  
        }  
        // 消费条件满足情况下，消费num个产品  
        for (int i = 1; i <= num; ++i)  
        {  
            try  
            {  
                // 消费产品，自动阻塞  
                list.take();  
            }  
            catch (InterruptedException e)  
            {  
                e.printStackTrace();  
            }  
        }  
        System.out.println("【现仓储量为】:" + list.size());  
    }  
  
    // set/get方法  
    public LinkedBlockingQueue<Object> getList()  
    {  
        return list;  
    }  
    public void setList(LinkedBlockingQueue<Object> list)  
    {  
        this.list = list;  
    }  
    public int getMAX_SIZE()  
    {  
        return MAX_SIZE;  
    }  
}  
【库存量】:0 暂时不能执行生产任务!  
【库存量】:0 暂时不能执行生产任务!  
【现仓储量为】:1  
【现仓储量为】:1  
【现仓储量为】:3  
【现仓储量为】:4  
【现仓储量为】:5  
【现仓储量为】:6  
【现仓储量为】:7  
【现仓储量为】:8  
【现仓储量为】:9  
【现仓储量为】:10  
【现仓储量为】:11  
【现仓储量为】:1  
【现仓储量为】:2  
【现仓储量为】:13  
【现仓储量为】:14  
【现仓储量为】:17  
【现仓储量为】:19  
【现仓储量为】:20  
【现仓储量为】:21  
【现仓储量为】:22  
【现仓储量为】:23  
【现仓储量为】:24  
【现仓储量为】:25  
【现仓储量为】:26  
【现仓储量为】:12  
【现仓储量为】:1  
【现仓储量为】:1  
【现仓储量为】:2  
【现仓储量为】:3  
【现仓储量为】:4  
【现仓储量为】:5  
【现仓储量为】:6  
【现仓储量为】:7  
【现仓储量为】:27  
【现仓储量为】:8  
【现仓储量为】:6  
【现仓储量为】:18  
【现仓储量为】:2  
【现仓储量为】:3  
【现仓储量为】:4  
【现仓储量为】:5  
【现仓储量为】:6  
【现仓储量为】:7  
【现仓储量为】:8  
【现仓储量为】:9  
【现仓储量为】:10  
【现仓储量为】:16  
【现仓储量为】:11  
【现仓储量为】:12  
【现仓储量为】:13  
【现仓储量为】:14  
【现仓储量为】:15  
【现仓储量为】:1  
【现仓储量为】:2  
【现仓储量为】:3  
【现仓储量为】:3  
【现仓储量为】:15  
【现仓储量为】:1  
【现仓储量为】:0  
【现仓储量为】:1  
【现仓储量为】:1  
【现仓储量为】:1  
【现仓储量为】:2  
【现仓储量为】:3  
【现仓储量为】:4  
【现仓储量为】:0  
【现仓储量为】:1  
【现仓储量为】:5  
【现仓储量为】:6  
【现仓储量为】:7  
【现仓储量为】:8  
【现仓储量为】:9  
【现仓储量为】:10  
【现仓储量为】:11  
【现仓储量为】:12  
【现仓储量为】:13  
【现仓储量为】:14  
【现仓储量为】:15  
【现仓储量为】:16  
【现仓储量为】:17  
【现仓储量为】:1  
【现仓储量为】:1  
【现仓储量为】:2  
【现仓储量为】:3  
【现仓储量为】:4  
【现仓储量为】:5  
【现仓储量为】:6  
【现仓储量为】:3  
【现仓储量为】:3  
【现仓储量为】:1  
【现仓储量为】:2  
【现仓储量为】:3  
【现仓储量为】:4  
【现仓储量为】:5  
【现仓储量为】:6  
【现仓储量为】:7  
【现仓储量为】:8  
【现仓储量为】:9  
【现仓储量为】:10  
【现仓储量为】:11  
【现仓储量为】:12  
【现仓储量为】:13  
【现仓储量为】:14  
【现仓储量为】:15  
【现仓储量为】:16  
【现仓储量为】:17  
【现仓储量为】:18  
【现仓储量为】:19  
【现仓储量为】:6  
【现仓储量为】:7  
【现仓储量为】:8  
【现仓储量为】:9  
【现仓储量为】:10  
【现仓储量为】:11  
【现仓储量为】:12  
【现仓储量为】:13  
【现仓储量为】:14  
【现仓储量为】:15  
【现仓储量为】:16  
【现仓储量为】:17  
【现仓储量为】:18  
【现仓储量为】:19  
【现仓储量为】:20  
【现仓储量为】:21  
【现仓储量为】:22  
【现仓储量为】:23  
【现仓储量为】:24  
【现仓储量为】:25  
【现仓储量为】:26  
【现仓储量为】:27  
【现仓储量为】:28  
【现仓储量为】:29  
【现仓储量为】:30  
【现仓储量为】:31  
【现仓储量为】:32  
【现仓储量为】:33  
【现仓储量为】:34  
【现仓储量为】:35  
【现仓储量为】:36  
【现仓储量为】:37  
【现仓储量为】:38  
【现仓储量为】:39  
【现仓储量为】:40

 

当然，你会发现这时对于public void produce(int num);和public void consume(int num);方法业务逻辑上的实现跟前面两个例子不太一样，没关系，这个例子只是为了说明BlockingQueue阻塞队列的使用。

 

有时使用BlockingQueue可能会出现put()和System.out.println()输出不匹配的情况，这是由于它们之间没有同步造成的。当缓冲区已满，生产者在put()操作时，put()内部调用了await()方法，放弃了线程的执行，然后消费者线程执行，调用take()方法，take()内部调用了signal()方法，通知生产者线程可以执行，致使在消费者的println()还没运行的情况下生产者的println()先被执行，所以有了输出不匹配的情况。

对于BlockingQueue大家可以放心使用，这可不是它的问题，只是在它和别的对象之间的同步有问题。

分享到：
| MySQl 索引分析
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java生产者消费者demo

    生产者/消费者问题的多种Java实现方式。采用适配器模式架构完成三种方式的实现。demo清晰明了

    Java多种方式实现生产者消费者模式

    主要介绍了Java多种方式实现生产者消费者模式,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

    java集成rabbitmq多种消费模式

    该项目包括两个子工程，生产者（rabbitmqProvider），消费者（rabbitmqConsumer），采用了direct，fanout，topic三种方式发布及消费。以及持久化分批消费等。工程中rabbitMQ.xml，rabbitMQ1.xml，rabbitMQChanel.xml...

    java jdk实列宝典 光盘源代码

    生产者、消费者问题；线程的优先级；列出虚拟机中所有的线程；守护线程Daemon；线程池；一个死锁的例子； 定时器Timer：包括在指定时间执行任务，在指定时间之后执行任务以及在某个时间之后每隔时间段重复执行的任务...

    Java并发编程原理与实战

    通过生产者消费者模型理解等待唤醒机制.mp4 Condition的使用及原理解析.mp4 使用Condition重写waitnotify案例并实现一个有界队列.mp4 深入解析Condition源码.mp4 实战：简易数据连接池.mp4 线程之间通信之join应用与...

    Java 面试题 word文档

    13. synchronized (生产者和消费） 14. String 和 StringBuffer 15. Serializable 16. MVC （Struts 的工作流程） 17. 什么是 MDA 18. tcp 与 udp 的区别 19. 链表与散列表和数组的区别 20. 堆和栈的区别 21. ejb 的...

    JAVA 范例大全 光盘 资源

    实例135 模拟生产者与消费者 392 实例136 仿迅雷下载文件 396 第15章 图形编程 403 实例137 多变的按钮 403 实例138 自制对话框 405 实例139 模仿QQ空间的电子相册 409 实例140 会动的七彩文字 413 实例141 ...

    龙果java并发编程完整视频

    第30节通过生产者消费者模型理解等待唤醒机制00:20:50分钟 | 第31节Condition的使用及原理解析00:17:40分钟 | 第32节使用Condition重写wait/notify案例并实现一个有界队列00:22:05分钟 | 第33节深入解析Condition...

    龙果 java并发编程原理实战

    第30节通过生产者消费者模型理解等待唤醒机制00:20:50分钟 | 第31节Condition的使用及原理解析00:17:40分钟 | 第32节使用Condition重写wait/notify案例并实现一个有界队列00:22:05分钟 | 第33节深入解析Condition...

    Spring 实现远程访问详解——jms和activemq

    它主要用于在生产者和消费者之间进行消息传递，生产者负责产生消息，而消费者负责接收消息。把它应用到实际的业务需求中的话我们可以在特定的时候利用生产者生成一消息，并进行发送，对应的消费者在接收到对应的消息...

    RabbitMQ 知识全面详解（值得珍藏）

    生产者是发送消息的应用，消费者是接收消息的应用，队列是存储消息的缓存，消息则是由生产者通过RabbitMQ发送给消费者的信息。 RabbitMQ的优势在于它支持多种客户端，具有易用性、扩展性和高可用性。它还提供了丰富...

    Java 并发编程原理与实战视频

    第30节通过生产者消费者模型理解等待唤醒机制00:20:50分钟 | 第31节Condition的使用及原理解析00:17:40分钟 | 第32节使用Condition重写wait/notify案例并实现一个有界队列00:22:05分钟 | 第33节深入解析Condition...

    java并发编程

    第30节通过生产者消费者模型理解等待唤醒机制00:20:50分钟 | 第31节Condition的使用及原理解析00:17:40分钟 | 第32节使用Condition重写wait/notify案例并实现一个有界队列00:22:05分钟 | 第33节深入解析Condition...

    java自学之道

    3.10 生产者消费者的实现 3.11 银行家算法 3.12 KMP算法 3.13 RSA的实现 第4章 IO流实例开发 4.1流到底怎样输入和输出扯淡区 4.2 FileInputStream的应用 4.3 FileOutputStream的应用 4.4 FileReader的应用 4.5 ...

    SpringBoot项目基于Web的农产品直卖平台的设计与实现.zip

    SpringBoot项目基于Web的农产品直卖平台是一个为农民和消费者设计的网络应用程序，旨在创建一个直接连接生产者和买家的市场，以促进农产品的销售并提高其价值。该系统通过集成产品展示、订单处理、支付和物流跟踪等...

    Java并发编程实战

    5.3　阻塞队列和生产者-消费者模式73 5.3.1　示例：桌面搜索75 5.3.2　串行线程封闭76 5.3.3　双端队列与工作密取77 5.4　阻塞方法与中断方法77 5.5　同步工具类78 5.5.1　闭锁79 5.5.2　FutureTask80 5.5.3　信号量...

    25道RabbitMQ面试题含答案（很全）

    在RabbitMQ中，一些核心概念包括生产者（发送消息的应用）、消费者（接收消息的应用）、队列（存储消息的缓存）、消息（由生产者通过RabbitMQ发送给消费者的信息）、连接（连接RabbitMQ和应用服务器的TCP连接）以及...

    BOS技术整理-05

    编写服务接口 打上@path配置路径 @get等请求方式 @Produces 生产者@Consumes 消费者 条件中 @PathParam 适用于@path上标识参数类型 客户端需要使用type 条件中 @QueryParam 适用于@path上标识不参数类型 编写...

Magicbox
Global site tag (gtag.js) - Google Analytics