java高级---->Thread之BlockingQueue的使用

最新推荐文章于 2025-06-21 12:20:11 发布

转载最新推荐文章于 2025-06-21 12:20:11 发布 · 396 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/huhx/p/baseusejavaBlockingQueue.html

文章标签：

#java

本文介绍 Java 中 BlockingQueue 的基本用法及 ArrayBlockingQueue 的具体应用。通过实例演示了如何使用 Producer 和 Consumer 模式实现线程间的同步和阻塞。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

　　今天我们通过实例来学习一下BlockingQueue的用法。梦想，可以天花乱坠，理想，是我们一步一个脚印踩出来的坎坷道路。

BlockingQueue的实例

官方文档上的对于BlockingQueue的说明：

A Queue that additionally supports operations that wait for the queue to become non-empty when retrieving an element, and wait for space to become available in the queue when storing an element.

如果BlockQueue是空的,从BlockingQueue取东西的操作将会被阻断进入等待状态,直到BlockingQueue进了东西才会被唤醒.同样,如果BlockingQueue是满的,任何试图往里存东西的操作也会被阻断进入等待状态,直到BlockingQueue里有空间才会被唤醒继续操作

一、BlockingQueue的简单使用

package com.linux.huhx.concurreny;

import java.util.Random;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.TimeUnit;

public class BlockingQueueTest {
    public static void main(String[] args) {
        BlockingQueue q = new LinkedBlockingDeque();
        Producer p = new Producer(q);
        Consumer c1 = new Consumer(q);
        Consumer c2 = new Consumer(q);
        new Thread(p).start();
        new Thread(c1).start();
        new Thread(c2).start();
    }

    static class Producer implements Runnable {
        private final BlockingQueue<String> queue;
        Producer(BlockingQueue<String> queue) {
            this.queue = queue;
        }
        @Override
        public void run() {
            for (int i = 0; i < 4; i++) {
                try {
                    queue.put("producer" + i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    static class Consumer implements Runnable {
        private final BlockingQueue queue;
        Consumer(BlockingQueue queue) {
            this.queue = queue;
        }
        public void run() {
            for (int i = 0; i < 2; i++) {
                try {
                    TimeUnit.MILLISECONDS.sleep(new Random().nextInt(2000));
                    System.out.println(queue.take());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

运行的结果如下：使用put和take方法，打印的结果是固定的。它会阻塞。

producer0
producer1
producer2
producer3

二、ArrayBlockIngQueue的使用

package com.linux.thread.thread;

import org.junit.Test;

import java.util.concurrent.ArrayBlockingQueue;

public class ArrayBlockQueueTest {
    @Test
    public void put() {
        try {
            ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<String>(3);
            queue.put("huhx");
            queue.put("linux");
            queue.put("ll");
            System.out.println("size: " + queue.size());
            System.out.println("begin: " + System.currentTimeMillis());
            queue.put("tomhu"); // 阻塞
            System.out.println("end: " + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Test
    public void get() {
        try {
            ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<String>(3);
            System.out.println("begin: " + System.currentTimeMillis());
            System.out.println(queue.take()); // 阻塞
            System.out.println("end: " + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}