Java BlockingQueue示例

最新推荐文章于 2024-05-09 07:15:00 发布
最新推荐文章于 2024-05-09 07:15:00 发布
阅读量793 收藏 3
点赞数
文章标签： java git runtime

在Java中，我们可以使用BlockingQueue创建生产者和消费者共享的队列。

  1. 生产者–生成数据并将其放入队列。
  2. 使用者–从队列中删除数据。

注意
阅读本文以了解什么是生产者和消费者 。

BlockingQueue实现是线程安全的，可以安全地与多个生产者和多个使用者一起使用。

1. BlockingQueue

一个简单的BlockingQueue示例，生产者生成数据并将其放入队列中，与此同时，消费者从同一队列中获取数据。

1.1生产者–一个Runnable对象，将20个整数放入队列中。

ExecutorExample1.java 
package com.mkyong.concurrency.queue.simple.raw;

import java.util.concurrent.BlockingQueue;

public class Producer implements Runnable {

    private final BlockingQueue<Integer> queue;

    @Override
    public void run() {

        try {
            process();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

    }

    private void process() throws InterruptedException {

        // Put 20 ints into Queue
        for (int i = 0; i < 20; i++) {
            System.out.println("[Producer] Put : " + i);
            queue.put(i);
            System.out.println("[Producer] Queue remainingCapacity : " + queue.remainingCapacity());
            Thread.sleep(100);
        }

    }

    public Producer(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }
}

1.2消费品-甲Runnable对象采取从队列项目。

Consumer.java 
package com.mkyong.concurrency.queue.simple.raw;

import java.util.concurrent.BlockingQueue;

public class Consumer implements Runnable {

    private final BlockingQueue<Integer> queue;

    @Override
    public void run() {

        try {
            while (true) {
                Integer take = queue.take();
                process(take);
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

    }

    private void process(Integer take) throws InterruptedException {
        System.out.println("[Consumer] Take : " + take);
        Thread.sleep(500);
    }

    public Consumer(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }
}

1.3运行。 启动1个生产者和1个消费者，并创建一个大小为10的队列。

Main.java 
package com.mkyong.concurrency.queue.simple;

import com.mkyong.concurrency.queue.simple.raw.Consumer;
import com.mkyong.concurrency.queue.simple.raw.Producer;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class Main {

    public static void main(String[] args) {

        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(10);

        new Thread(new Producer(queue)).start();
        new Thread(new Consumer(queue)).start();

    }

}

输出量

如果数据已满，生产者将不会尝试将更多数据放入队列。 

[Producer] Put : 0
[Producer] Queue remainingCapacity : 9
[Consumer] Take : 0
[Producer] Put : 1
[Producer] Queue remainingCapacity : 9
[Producer] Put : 2
[Producer] Queue remainingCapacity : 8
[Producer] Put : 3
[Producer] Queue remainingCapacity : 7
[Producer] Put : 4
[Producer] Queue remainingCapacity : 6
[Producer] Put : 5
[Producer] Queue remainingCapacity : 5
[Consumer] Take : 1
[Producer] Put : 6
[Producer] Queue remainingCapacity : 5
[Producer] Put : 7
[Producer] Queue remainingCapacity : 4
[Producer] Put : 8
[Producer] Queue remainingCapacity : 3
[Producer] Put : 9
[Producer] Queue remainingCapacity : 2
[Producer] Put : 10
[Producer] Queue remainingCapacity : 1
[Consumer] Take : 2
[Producer] Put : 11
[Producer] Queue remainingCapacity : 1
[Producer] Put : 12
[Producer] Queue remainingCapacity : 0
[Producer] Put : 13
[Consumer] Take : 3
[Producer] Queue remainingCapacity : 0
[Producer] Put : 14
[Consumer] Take : 4
[Producer] Queue remainingCapacity : 0
[Producer] Put : 15
[Consumer] Take : 5
[Producer] Queue remainingCapacity : 0
[Producer] Put : 16
[Consumer] Take : 6
[Producer] Queue remainingCapacity : 0
[Producer] Put : 17
[Consumer] Take : 7
[Producer] Queue remainingCapacity : 0
[Producer] Put : 18
[Consumer] Take : 8
[Producer] Queue remainingCapacity : 0
[Producer] Put : 19
[Consumer] Take : 9
[Producer] Queue remainingCapacity : 0
[Consumer] Take : 10
[Consumer] Take : 11
[Consumer] Take : 12
[Consumer] Take : 13
[Consumer] Take : 14
[Consumer] Take : 15
[Consumer] Take : 16
[Consumer] Take : 17
[Consumer] Take : 18
[Consumer] Take : 19

该程序不会停止或退出，它将继续在那里运行，以从BlockingQueue放入和取出数据

2. BlockingQueue +毒药

“毒丸”是停止或中断生产者线程和使用者线程的一般解决方案。 想法是生产者将“毒丸”放入队列并退出，如果“消费者”看到“毒丸”，则停止并退出。

2.1使用毒丸溶液的生产者。

ProducerPoison.java 
package com.mkyong.concurrency.queue.simple.poison;

import java.util.concurrent.BlockingQueue;

public class ProducerPoison implements Runnable {

    private final BlockingQueue<Integer> queue;
    private final Integer POISON;

    @Override
    public void run() {

        try {
            process();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            while (true) {
                try {
                    queue.put(POISON);
                    break;
                } catch (InterruptedException e) {
                    //...
                }
            }
        }

    }

    private void process() throws InterruptedException {

        // Put 20 elements into Queue
        for (int i = 0; i < 20; i++) {
            System.out.println("[Producer] Put : " + i);
            queue.put(i);
            System.out.println("[Producer] Queue remainingCapacity : " + queue.remainingCapacity());
            Thread.sleep(100);
        }

    }

    public ProducerPoison(BlockingQueue<Integer> queue, Integer POISON) {
        this.queue = queue;
        this.POISON = POISON;
    }

}

2.2有毒药丸溶液的消费者。

ConsumerPoison.java 
package com.mkyong.concurrency.queue.simple.poison;

import java.util.concurrent.BlockingQueue;

public class ConsumerPoison implements Runnable {

    private final BlockingQueue<Integer> queue;
    private final Integer POISON;

    @Override
    public void run() {

        try {
            while (true) {
                Integer take = queue.take();
                process(take);

                // if this is a poison pill, break, exit
                if (take == POISON) {
                    break;
                }

            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

    }

    private void process(Integer take) throws InterruptedException {
        System.out.println("[Consumer] Take : " + take);
        Thread.sleep(500);
    }

    public ConsumerPoison(BlockingQueue<Integer> queue, Integer POISON) {
        this.queue = queue;
        this.POISON = POISON;
    }
}

2.3开始2个生产者和2个消费者。

Main.java 
package com.mkyong.concurrency.queue.simple;

import com.mkyong.concurrency.queue.simple.poison.ConsumerPoison;
import com.mkyong.concurrency.queue.simple.poison.ProducerPoison;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class Main {

    public static void main(String[] args) {

        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(10);

        //new Thread(new Producer(queue)).start();
        //new Thread(new Consumer(queue)).start();

        Integer poison = -1;
        new Thread(new ProducerPoison(queue, poison)).start();
        new Thread(new ProducerPoison(queue, poison)).start();

        new Thread(new ConsumerPoison(queue, poison)).start();
        new Thread(new ConsumerPoison(queue, poison)).start();

    }

}

输出量 

[Producer] Put : 0
[Producer] Put : 0
[//...
[Consumer] Take : 18
[Consumer] Take : 18
[Consumer] Take : 19
[Consumer] Take : 19
[Consumer] Take : -1
[Consumer] Take : -1

Process finished with exit code 0

3. BlockingQueue +文件索引

一个BlockingQueue示例，用于创建简单的文件索引引擎。 生产者对目录进行爬网，然后将文件名放入队列中，与此同时，消费者从同一队列中获取文件名并为其建立索引。

3.1生产者。

FileCrawlerProducer.java 
package com.mkyong.concurrency.queue.crawler;

import java.io.File;
import java.io.FileFilter;
import java.util.concurrent.BlockingQueue;

// Producer
// Crawl file system and put the filename in BlockingQueue.
public class FileCrawlerProducer implements Runnable {

    private final BlockingQueue<File> fileQueue;
    private final FileFilter fileFilter;
    private final File file;
    private final File POISON;
    private final int N_POISON_PILL_PER_PRODUCER;

    @Override
    public void run() {

        try {
            crawl(file);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            while (true) {
                try {
                    System.out.println(Thread.currentThread().getName()
                            + " - FileCrawlerProducer is done, try poison all the consumers!");
                    // poison all threads
                    for (int i = 0; i < N_POISON_PILL_PER_PRODUCER; i++) {
                        System.out.println(Thread.currentThread().getName() + " - puts poison pill!");
                        fileQueue.put(POISON);
                    }
                    break;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }

    public FileCrawlerProducer(BlockingQueue<File> fileQueue,
                               FileFilter fileFilter, File file, 
                               File POISON, int n_POISON_PILL_PER_PRODUCER) {
        this.fileQueue = fileQueue;
        this.fileFilter = fileFilter;
        this.file = file;
        this.POISON = POISON;
        N_POISON_PILL_PER_PRODUCER = n_POISON_PILL_PER_PRODUCER;
    }

    private void crawl(File root) throws InterruptedException {

        File[] entries = root.listFiles(fileFilter);
        if (entries != null) {
            for (File entry : entries) {
                if (entry.isDirectory()) {
                    crawl(entry);
                } else if (!isIndexed(entry)) {
                    System.out.println("[FileCrawlerProducer] - Found..." 
                            + entry.getAbsoluteFile());
                    fileQueue.put(entry);
                }
            }
        }

    }

    private boolean isIndexed(File f) {
        return false;
    }

}

3.2消费者。

IndexerConsumer.java 
package com.mkyong.concurrency.queue.crawler;

import java.io.File;
import java.util.concurrent.BlockingQueue;

// Consumer
public class IndexerConsumer implements Runnable {

    private final BlockingQueue<File> fileQueue;
    private final File POISON;

    @Override
    public void run() {

        try {
            while (true) {
                File take = fileQueue.take();
                if (take == POISON) {
                    System.out.println(Thread.currentThread().getName() + " die");
                    break;
                }
                indexFile(take);
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

    }

    public void indexFile(File file) {
        if (file.isFile()) {
            System.out.println(Thread.currentThread().getName() 
                    + " [IndexerConsumer] - Indexing..." + file.getAbsoluteFile());
        }

    }

    public IndexerConsumer(BlockingQueue<File> fileQueue, File POISON) {
        this.fileQueue = fileQueue;
        this.POISON = POISON;
    }
}

3.3开始1个生产者和2个消费者。

Main.java 
package com.mkyong.concurrency.queue.crawler;

import java.io.File;
import java.io.FileFilter;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class Main {

    private static final File POISON = new File("This is a POISON PILL");

    public static void main(String[] args) {

        int N_PRODUCERS = 1;
        int N_CONSUMERS = 2;//Runtime.getRuntime().availableProcessors();
        int N_POISON_PILL_PER_PRODUCER = N_CONSUMERS / N_PRODUCERS;
        int N_POISON_PILL_REMAIN = N_CONSUMERS % N_PRODUCERS;

        System.out.println("N_PRODUCERS : " + N_PRODUCERS);
        System.out.println("N_CONSUMERS : " + N_CONSUMERS);
        System.out.println("N_POISON_PILL_PER_PRODUCER : " + N_POISON_PILL_PER_PRODUCER);
        System.out.println("N_POISON_PILL_REMAIN : " + N_POISON_PILL_REMAIN);

        //unbound queue, no limit
        BlockingQueue<File> queue = new LinkedBlockingQueue<>();

        FileFilter filter = new FileFilter() {
            public boolean accept(File file) {
                return true;
            }
        };

        File root = new File("C:\\users");

        for (int i = 0; i < N_PRODUCERS - 1; i++) {
            new Thread(new FileCrawlerProducer(queue, filter, root,
                    POISON, N_POISON_PILL_PER_PRODUCER)).start();
        }
        new Thread(new FileCrawlerProducer(queue, filter, root, POISON,
                N_POISON_PILL_PER_PRODUCER + N_POISON_PILL_REMAIN)).start();

        for (int i = 0; i < N_CONSUMERS; i++) {
            new Thread(new IndexerConsumer(queue, POISON)).start();
        }

    }
}

输出量 

//...
[FileCrawlerProducer] - Found...C:\users\Public\Videos\desktop.ini
Thread-2 [IndexerConsumer] - Indexing...C:\users\Public\Videos\desktop.ini
Thread-0 - FileCrawlerProducer is done, try poison all the consumers!
Thread-0 - puts poison pill!
Thread-0 - puts poison pill!
Thread-1 die
Thread-2 die

Process finished with exit code 0

下载源代码

git clone https://github.com/mkyong/java-concurrency.git

参考文献

  1. 生产者－消费者问题
  2. BlockingQueue JavaDoc
标签：

翻译自: https://mkyong.com/java/java-blockingqueue-examples/

cyan20115
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于java中BlockingQueue的使用介绍
09-05
**基于Java中的BlockingQueue使用介绍** Java的并发编程框架提供了多种高级并发工具，其中BlockingQueue是一种非常实用的数据结构，它实现了生产者-消费者模式。在多线程环境下，BlockingQueue可以高效地处理线程间...
java线程并发blockingqueue类使用示例
09-04
BlockingQueue是一种特殊的Queue，若BlockingQueue是空的，从BlockingQueue取东西的操作将会被阻断进入等待状态直到BlocingkQueue进了新货才会被唤醒,下面是用BlockingQueue来实现Producer和Consumer的例子
java linkedblockingqueue capacity,Java LinkedBlockingQueue remainingCapacity()用法及代码示例
weixin_31631571的博客
03-10 682
LinkedBlockingQueue的remainingCapacity()方法返回可以无限制添加到LinkedBlockingQueue的更多元素的数量。返回的Thr容量出现三种情况：如果剩余容量为零，则不能再将其他元素添加到LinkedBlockingQueue。如果LinkedBlockingQueue的剩余Capacity等于Queue的大小，则无法从队列中删除任何元素，因为在这种情况下...
java ArrayBlockingQueue 使用示例
彻底拆分，一切可控！
03-18 9479
import java.util.concurrent.ArrayBlockingQueue; public class TestArrayBlocking { public static void main(String[] args) throws Exception { // insertBlocking(); // fetchBlocking(); ArrayBlock
Java并发控制：深入解析Java BlockingQueue的用法与实践
最新发布
逆流的小鱼
05-09 708
BlockingQueue是一个支持两个附加操作的Queue，即在队列为空时获取元素的线程会等待队列变为非空，当队列满时存储元素的线程会等待队列可用。这主要用于生产者-消费者场景，其中生产者不能添加对象到队列中间，直到有可用空间，反之消费者也不能从队列中获取对象，直到有对象可用。
Java中 BlockingQueue（阻塞队列）的使用
JoJo小风
09-20 4556
引言Queue接口与List、Set同一级别，都是继承了Collection接口。LinkedList实现了Queue接 口。Queue接口窄化了对LinkedList的方法的访问权限（即在方法中的参数类型如果是Queue时，就完全只能访问Queue接口所定义的方法 了，而不能直接访问 LinkedList的非Queue的方法），以使得只有恰当的方法才可以使用。BlockingQueue 继承了Qu
Java并发阻塞队列BlockingQueue概览
青山师
07-22 745
BlockingQueuejava.util.concurrent包下的 BlockingQueue 接口规范了一个放数据、取数据都是线程安全的队列。 BlockingQueue的用法一个典型的使用 BlockingQueue 的应用场景是 生产-消费者模型。 一个线程往队列生产数据，另一个队列消耗数据生产线程会持续生产新的实例放入队列中，直到队列容量达到指定值。也就是说，如果队列数据大小达
BlockingQueue阻塞队列案例
weixin_45417821的博客
07-20 391
文章目录队列和栈BlockingQueue 简介BlockingQueue 核心方法BlockingQueue 的核心方法1.放入数据2.获取数据入门案例常见的 BlockingQueueArrayBlockingQueue(常用)LinkedBlockingQueue(常用)DelayQueuePriorityBlockingQueueSynchronousQueueLinkedTransferQueueLinkedBlockingDeque小结 队列和栈 队列是先进先出，栈是后进先出。 Blockin
java 中 阻塞队列BlockingQueue详解及实例
08-30
Java中的阻塞队列BlockingQueue是一种并发编程中常用的工具，它实现了线程间的同步和通信。阻塞队列的核心特性在于当队列为空时，尝试获取元素的线程会被阻塞，直到其他线程添加元素；当队列满时，尝试添加元素的...
executor:Java 执行器示例
07-21
8. **并发工具类**：`java.util.concurrent`包还提供了许多并发工具类，如`BlockingQueue`、`Semaphore`、`CountDownLatch`等，它们在多线程编程中也有广泛应用。 这个示例项目可能通过这些组件展示了如何在Java中...
Java-Thread-Pool-example:一个简单的 Java 线程池示例
07-04
4. **工作队列** (BlockingQueue)：用来存储等待执行的任务，线程池会从队列中取出任务分配给线程执行。常见的有无界队列（如ArrayBlockingQueue）和有界队列（如LinkedBlockingQueue）。 线程池的创建通常使用`...
Java线程(十三)：BlockingQueue-线程的阻塞队列
且听风吟的专栏
09-26 2万+
BlockingQueue作为线程容器，可以为线程同步提供有力的保障，其主要用到的方法包括： add(E o); //将指定的元素添加到此队列中（如果立即可行），在成功时返回 true，其他情况则抛出 IllegalStateException。 drainTo(Collection c); //移除此队列中所有可用的元素，并将它们添加到给定 collection 中。 drainTo
BlockingQueue（阻塞队列）详解
kaven
02-19 1787
BlockingQueue（阻塞队列）详解 原文地址 BlockingQueue 一. 前言 在新增的Concurrent包中，BlockingQueue很好的解决了多线程中，如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类，为我们快速搭建高质量的多线程程序带来极大的便利。本文详细介绍了BlockingQueue家庭中的所有成员，包括他们各自的功能以及常见使用场景。 二. 认识Bl...
java queue put take_Java 阻塞队列 BlockingQueue 详解: put,add 和 offer 三个方法
weixin_33078391的博客
02-24 243
BlockingQueuejava.util.concurrent public interface BlockingQueue extends QueueA Queue that additionally supports operations that wait for the queue to become non-empty when retrieving an element, and ...
【细谈Java并发】谈谈LinkedBlockingQueue
热门推荐
颤抖吧腿子
10-26 12万+
最近在看concurrent包的知识，看到LinkedBlockingQueue，发现一篇好文推荐给大家。 原文地址：【细谈Java并发】谈谈LinkedBlockingQueue 1、简介 上篇我们介绍了ArrayBlockingQueue的相关方法的原理，这一篇我们来学习一下ArrayBlockingQueue的“亲戚” LinkedBlockingQueue。在集合框架里，想必大家都用过Ar...
LinkedBlockingQueue 例子
在水一方
06-07 434
[code="java"] import java.util.Random; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurren...
java blockqueue_java blockingQueue 原理
weixin_32350433的博客
02-16 302
blockingQueue 阻塞队列，一般用于消费者生产者模式。 就是通过ReentrantLock和condition实现的阻塞，1 /**Main lock guarding all access*/2 finalReentrantLock lock;3 /**Condition for waiting takes*/4 private finalConditi...
BlockingQueue使用实例
weixin_43861630的博客
01-26 308
ArrayBlockingQueue 阻塞队列 FIFO 先进先出 public static void main(String[] args) throws InterruptedException { // test1(); test4(); } //有返回值 抛出异常 public static void test1(){ //队列大小 ArrayBlockingQueue blockingQueue
Java 使用阻塞队列 BlockingQueue 多线程搜索目录及子目录下包含关键字所有文件
XnCSD的博客
06-23 740
Java 使用阻塞队列 BlockingQueue 多线程在一个目录及它的所以子目录下搜索所有文件，打印出包含关键字的行 阻塞队列（ blocking queue ) 生产者线程向队列插人元素， 消费者线程则取出它们。使用队列，可以安全地从一个线程向另一个线程传递数据。 工作者线程可以周期性地将中间结果存储在阻塞队列中。其他的工作者线程移出中间结果并进一步加以修改。队列会自动地平衡负载。如...
Java并发编程--BlockingQueue.docx
06-21
"Java并发编程-- BlockingQueue" Java并发编程中的`BlockingQueue`是一个重要的并发组件，它在多线程环境中扮演着数据共享的角色，特别适用于实现生产者-消费者模式。`BlockingQueue`是一个线程安全的队列，它提供...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值