BlockingQueue的简单使用

最新推荐文章于 2025-07-19 11:28:29 发布

wellven_chen

最新推荐文章于 2025-07-19 11:28:29 发布

阅读量2k

点赞数

CC 4.0 BY-SA版权

分类专栏： JAVA基础功能实例文章标签： java BlockingQueue ExecutorService

本文链接：https://blog.youkuaiyun.com/wellven_chen/article/details/80244108

JAVA基础功能实例专栏收录该内容

4 篇文章

订阅专栏

本文介绍了一个基于BlockingQueue的队列实现，通过自定义消息队列MessageQueue，并利用MessageBean作为消息载体，最后通过多线程测试验证了BlockingQueue的线程安全性及容量限制。

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

BlockingQueue是一个阻塞队列，用户可以为该队列设置一个初始容量（即该队列中最多能够放入多少个数据）。
既然是队列，那么肯定是由顺序的，我们可以调用给定的API依次获取往该队列中值的设置顺序。

第一步.

创建BlockingQueue的封装类，BlockingQueue能够在创建对象的时候使用泛型来规定队列的类型

package com.MessageQueue;

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

public class MessageQueue {

    private static BlockingQueue<MessageBean> blockingQueue;
    private static MessageQueue messageQueue;

    private MessageQueue() {
        // 规定BlockingQueue的容量
        blockingQueue = new LinkedBlockingQueue<MessageBean>(100);
    }

    public static MessageQueue getInstance() {
        if (messageQueue == null) {
            synchronized (MessageQueue.class) {
                if (messageQueue == null) {
                    messageQueue = new MessageQueue();
                }
            }
        }
        return messageQueue;
    }

    /**
     * 查看当前BlockingQueue的容量
     * 
     * @return
     */
    public int getMessageVol() {
        if (blockingQueue != null) {
            return blockingQueue.size();
        }
        return 0;
    }

    /**
     * 向BlockingQueue中放入指定的对象
     * 
     * @param message
     */
    public void put(MessageBean message) {
        try {
            blockingQueue.put(message);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 从BlockingQueue中提取指定对象
     * 
     * @return
     */
    public MessageBean take() {
        try {
            MessageBean message = blockingQueue.take();
            return message;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return null;
    }
}

第二步.

当然是创建对象的Bean类

package com.MessageQueue;

public class MessageBean {

    private int messageId;
    private String messageContext;

    public MessageBean(int messageId, String messageContext) {
        this.messageId = messageId;
        this.messageContext = messageContext;
    }

    public int getMessageId() {
        return messageId;
    }

    public void setMessageId(int messageId) {
        this.messageId = messageId;
    }

    public String getMessageContext() {
        return messageContext;
    }

    public void setMessageContext(String messageContext) {
        this.messageContext = messageContext;
    }

}

第三步.

创建BloackingQueue的测试类来检验是否成功

package com.MessageQueue;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MessageQueueTest implements Runnable {

    private static MessageQueue messageQueue;

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        messageQueue = MessageQueue.getInstance();
        MessageQueueTest thread = new MessageQueueTest();
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int a = 1; a <= 10; a++) {
            executorService.submit(thread);
        }
        int i = 0;
        for (; i < 200; i++) {
            MessageBean messagebean = new MessageBean(i, "The first message!");
            messageQueue.put(messagebean);
        }
        System.out.println("Now the message Queue size:" + messageQueue.getMessageVol());

    }

    @Override
    public void run() {
        while (true) {
            MessageBean getBean = messageQueue.take();
            System.out.println(getBean.getMessageId() + " : " + getBean.getMessageContext());
            System.out.println("Now the message Queue size:" + messageQueue.getMessageVol());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }
    }
}

从测试类中，我使用了多线程的方式去读取BlockingQueue中的数据，主要是为了测试BlockingQueue是否是真正是线程安全的和容量参数是否真的能够实现。

经过测试，的确如此。