LinkedBlockingQueue队列介绍及使用

刘大猫.

于 2025-06-11 09:57:20 发布

阅读量978

点赞数 16

CC 4.0 BY-SA版权

分类专栏： Spring及SpringBoot相关 JAVA相关文章标签： java 队列 Queue 队列使用队列介绍 LinkedBlocking LinkedQueue

本文链接：https://blog.youkuaiyun.com/a924382407/article/details/148579781

Spring及SpringBoot相关同时被 2 个专栏收录

50 篇文章

订阅专栏

JAVA相关

42 篇文章

订阅专栏

在这里插入图片描述

文章目录

一、介绍
二、LinkedBlockingQueue 和 ConcurrentHashMap区别
三、代码

一、介绍

LinkedBlockingQueue 是 Java 中一个线程安全的阻塞队列实现，属于 java.util.concurrent 包。它的主要用途是在多线程环境下进行数据的安全传递和存储。以下是 LinkedBlockingQueue 的主要特点和适用场景：

主要特点

线程安全:
- LinkedBlockingQueue 是线程安全的，多个线程可以同时进行插入和删除操作而不会引起数据的不一致性。
阻塞特性:
- 当队列为空时，调用 getData() 方法会使调用线程阻塞，直到有数据可供消费。
- 当队列已满时，调用 addData(T t) 方法会使调用线程阻塞，直到队列有空间可以添加新的元素。
容量限制:
- 可以在创建时指定队列的最大容量（如你的代码中 cacheSize），这使得你可以控制内存的使用。
FIFO（先进先出）:
- LinkedBlockingQueue 是一个 FIFO 队列，意味着最先添加的元素会最先被移除。

适用场景

LinkedBlockingQueue 适用于以下场景：

生产者-消费者模式:
- 在多线程应用中，常常需要将数据从一个线程（生产者）传递到另一个线程（消费者）。LinkedBlockingQueue 可以很好地支持这种模式，生产者可以将数据放入队列中，而消费者可以从队列中获取数据。
任务调度:
- 在任务调度系统中，可以使用 LinkedBlockingQueue 来存储待执行的任务，多个工作线程可以从队列中获取任务并执行。
事件处理:
- 在事件驱动的系统中，可以使用 LinkedBlockingQueue 来存储事件，事件处理线程可以从队列中获取事件并进行处理。
流控制:
- 通过设置队列的最大容量，可以控制流入和流出的数据速率，避免系统因为处理不过来而导致的内存溢出。

代码中的应用

在你提供的 AbstractQueueCache 类中，LinkedBlockingQueue 被用作缓存机制，主要用于以下目的：

数据缓存: 通过 addData()、getData() 等方法，类提供了一个线程安全的方式来管理数据缓存。
阻塞行为: 当数据缓存满时，新的数据添加会被阻塞，直到有空间可用；当缓存为空时，数据获取会被阻塞，直到有数据可用。这种行为适合需要确保数据处理顺序和完整性的场景。
批量处理: 提供了批量添加和获取数据的方法，适合需要处理一组数据的场景。

总之，LinkedBlockingQueue 是一个非常有用的工具，适用于需要线程安全和阻塞特性的多线程应用场景。

二、LinkedBlockingQueue 和 ConcurrentHashMap区别

LinkedBlockingQueue 和 ConcurrentHashMap 都是 Java 中用于并发编程的集合类，但它们的设计目的和适用场景是不同的。以下是它们的主要区别和各自的用途：

数据结构
- LinkedBlockingQueue:
  - 是一个阻塞队列，主要用于存储元素的顺序集合，遵循 FIFO（先进先出）原则。
  - 适用于需要处理任务或数据流的场景，例如生产者-消费者模式。
- ConcurrentHashMap:
  - 是一个线程安全的哈希表，主要用于存储键值对（key-value pairs），提供快速的查找、插入和删除操作。
  - 适合用于需要快速查找和更新数据的场景。
使用场景
- LinkedBlockingQueue:
  - 适用于需要控制数据的流入和流出、需要阻塞行为的场景。例如：
    - 生产者-消费者模式：生产者将数据放入队列，消费者从队列中取出数据。队列会在满时阻塞生产者，在空时阻塞消费者。
    - 任务调度：多个线程从队列中获取任务并执行，确保任务的顺序和完整性。
- ConcurrentHashMap:
  - 适用于需要快速访问和修改数据的场景。例如：
    - 缓存：存储键值对，快速访问和更新数据。
    - 计数器：在多线程环境中管理和更新计数值。
线程安全的实现方式
- LinkedBlockingQueue:
  - 在内部使用了锁机制来实现线程安全，确保在插入和删除元素时的互斥访问。
- ConcurrentHashMap:
  - 使用分段锁（segment locking）机制来提高并发性能，允许多个线程同时访问不同的段。
阻塞行为
- LinkedBlockingQueue:
  - 提供了阻塞方法（如 put() 和 take()），当队列满时，插入操作会阻塞，直到有空间可用；当队列空时，获取操作会阻塞，直到有数据可用。
- ConcurrentHashMap:
  - 不提供阻塞操作，所有操作都是非阻塞的，适合快速查找和更新，但不适合需要流控制的场景。

结论:

如果你的应用场景需要在多线程环境中处理数据流（例如任务调度、生产者-消费者模式），并且需要控制数据的顺序和流入流出，那么 LinkedBlockingQueue 是更合适的选择。

如果你的应用场景需要快速访问和更新键值对数据，并且不需要阻塞行为，那么 ConcurrentHashMap 是更合适的选择。

因此，选择 LinkedBlockingQueue 还是 ConcurrentHashMap 取决于你的具体需求和场景。

三、代码

AbstractQueueCache

package com.hero.lte.ems.jms.support.cache;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

public abstract class AbstractQueueCache<T> implements ICacheManager
{
    protected int cacheSize;

    protected LinkedBlockingQueue<T> queue;

    protected AbstractQueueCache(int cacheSize)
    {
        this.cacheSize = cacheSize;
        queue = new LinkedBlockingQueue<>(cacheSize);
        DefaultCacheManager.getInstance().addCache(this);
    }

    /**
     * 添加数据，若cache已满，则等待
     * @param t
     * @throws InterruptedException
     */
    public void addData(T t) throws InterruptedException
    {
        if (null != t)
        {
            queue.put(t);
        }
    }

    /**
     * 添加数据，若cache已满，则等待指定的时间
     * @param t
     * @param waitTime
     * @param unit
     * @throws InterruptedException
     */
    public void addData(T t, long waitTime, TimeUnit unit) throws InterruptedException
    {
        if (null != t)
        {
            queue.offer(t, waitTime, unit);
        }
    }

    /**
     * 
     * @param dataList
     * @return
     */
    public boolean addDataList(List<T> dataList)
    {
        if (null != dataList)
        {
            List<T> temp = new ArrayList<>();
            for (T t : dataList)
            {
                if (null != t)
                {
                    temp.add(t);
                }
            }
            return queue.addAll(temp);
        }
        return false;
    }

    /**
     * 添加数据，若缓存满，返回false
     * @param t
     * @return
     */
    public boolean addDataWithoutBlock(T t)
    {
        if (null != t)
        {
            return queue.offer(t);
        }
        return false;
    }

    /**
     * 取数据，若空则等待
     * @return
     * @throws InterruptedException
     */
    public T getData() throws InterruptedException
    {
        return queue.take();
    }

    /**
     * 取数据，若空则等待指定的时间
     * @param waitTime 超时的时间
     * @param unit 超时单位
     * @return
     * @throws InterruptedException
     */
    public T getData(long waitTime, TimeUnit unit) throws InterruptedException
    {
        return queue.poll(waitTime, unit);
    }

    /**
     * 取数据，若空则返回null
     * @return
     * @throws InterruptedException
     */
    public T getDataWithOutBlock() throws InterruptedException
    {
        return queue.poll();
    }

    /**
     * 批量取值若为空则挂起
     * @param maxSize 最大取值个数
     * @return
     * @throws InterruptedException
     */
    public List<T> getDataList(int maxSize) throws InterruptedException
    {
        List<T> resultList = new ArrayList<>();
        resultList.add(getData());
        queue.drainTo(resultList, maxSize - 1);
        return resultList;
    }

    /**
     * 批量取值若为空则等待指定的时间
     * @param maxSize
     * @param waitTime 超时的时间
     * @param unit 超时的单位
     * @return
     * @throws InterruptedException
     */
    public List<T> getDataList(int maxSize, long waitTime, TimeUnit unit) throws InterruptedException
    {
        List<T> resultList = null;
        T t = getData(waitTime, unit);
        if (null != t)
        {
            resultList = new ArrayList<>();
            resultList.add(t);
            queue.drainTo(resultList, maxSize - 1);
        }

        return resultList;
    }

    /**
     * 批量取值，若为空返回空列表。
     * @param maxSize 最大取值个数
     * @return
     * @throws InterruptedException
     */
    public List<T> getDataListWithOutBlock(int maxSize) throws InterruptedException
    {
        List<T> resultList = new ArrayList<>();
        queue.drainTo(resultList, maxSize);
        return resultList;
    }

    public int getSize()
    {
        return queue.size();
    }

    @Override
    public void init()
    {

    }

    @Override
    public void destroy()
    {
        queue.clear();
        queue = null;
    }

}

BscAnalysisKPIJsonQueueCache

package com.hero.lte.ems.bsc.pm.cache;

import com.hero.lte.ems.bsc.pm.cache.model.BscAnalysisKPIJsonBean;
import com.hero.lte.ems.jms.support.cache.AbstractQueueCache;

public class BscAnalysisKPIJsonQueueCache extends AbstractQueueCache<BscAnalysisKPIJsonBean> {

    private static final Integer QUEUE_SIZE = 200000;

    private static final BscAnalysisKPIJsonQueueCache cache = new BscAnalysisKPIJsonQueueCache();

    private BscAnalysisKPIJsonQueueCache()

    {
        super(QUEUE_SIZE);
    }

    public static BscAnalysisKPIJsonQueueCache getInstance() {
        return cache;
    }

    public static int getInitQueueCapacity(){return QUEUE_SIZE;};
}

ICacheManager

package com.hero.lte.ems.jms.support.cache;

public interface ICacheManager
{
    void init();

    void destroy();
}

使用

private void readPmDatJson(List<String> pmDataJsonPath) throws IOException {
	try {
        BscAnalysisKPIJsonQueueCache.getInstance().addData(new BscAnalysisKPIJsonBean(jsonFilePath,x));
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
   }
}

@Override
public void run() {
    while (true)
    {
        try
        {
            Thread.sleep(10*1000);
            if(  BscAnalysisKPIJsonQueueCache.getInstance().getSize() > 0) {
                log.warn("2-BscAnalysisKPIJsonQueueCache-getSize:{}", BscAnalysisKPIJsonQueueCache.getInstance().getSize());
            }
            List<BscAnalysisKPIJsonBean> analysisKPIJsonList =  BscAnalysisKPIJsonQueueCache.getInstance().getDataList(100);
            if(analysisKPIJsonList!=null&&analysisKPIJsonList.size()>0){
                BscPmTaskExe.getAnalysisPoolExecutor().submit(new BscBatchAnsKpiTask(analysisKPIJsonList));
            }
        }
        catch (Throwable e)
        {
            log.error("scan BscAnalysisKPIJsonQueueCache queue failed. ", e);
        }
    }
}