Java多线程工具包java.util.concurrent---LinkedBlockingQueue

Posted 2022-12-11 yvan1115

LinkedBlockingQueue 简介

LinkedBlockingQueue 类实现了 BlockingQueue 接口。
LinkedBlockingQueue 内部以一个链式结构(链接节点)对其元素进行存储。如果需要的话，这一链式结构可以选择一个上限。如果没有定义上限，将使用 Integer.MAX_VALUE 作为上限。
LinkedBlockingQueue 内部以 FIFO(先进先出)的顺序对元素进行存储。队列中的头元素在所有元素之中是放入时间最久的那个，而尾元素则是最短的那个。

示例

这里模拟简单的客服系统，来说明其用法。

监控在线连接人数

class Customer implements Runnable 
    private LinkedBlockingQueue<String> users;

    public Customer(LinkedBlockingQueue<String> users) 
        this.users = users;
    

    @Override
    public void run() 
        while (true) 
            try 
                // 使用take 阻塞队列
                String user = users.take();
                System.out.println("用户" + user + "已经离开......," + "还有" + users.size() + "个人在连线");
             catch (InterruptedException e) 
                // TODO Auto-generated catch block
                e.printStackTrace();
            
        

    

模拟接入电话

class Productor implements Runnable 

    private String user;
    private LinkedBlockingQueue<String> users;

    public Productor(String user, LinkedBlockingQueue<String> users) 
        this.users = users;
        this.user = user;
    

    @Override
    public void run() 
        Random random = new Random();
        while (true) 
            // 客服是否已经接待满，接待满链阻塞队列被阻塞
            // 队列没有满之前不会阻塞队列
            boolean success = users.offer(user);
            try 
                if (success) 
                    int time = random.nextInt(6);
                    System.out.println("用户" + user + "已经接入客服");
                    System.out.println("通话时长"+time+"分钟");
                    TimeUnit.SECONDS.sleep(time);
                 else 
                    System.out.println("客服正忙，请稍后再拨.....");

                
             catch (Exception e) 
                e.printStackTrace();
            

        

    

测试

package com.yvan.linkedBlockingQueue;

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

/**
 * LinkedBlockingQueue
 * @author yvan
 *
 */
public class AppMain 

    // 客服总数
    private static final int _SERVICE = 7;
    // 拨打电话用户
    private static final int _USER = 10;

    public static void main(String[] args) 
        LinkedBlockingQueue<String> users = new LinkedBlockingQueue<>(_SERVICE);
        Customer customer = new Customer(users);
        ExecutorService executor = Executors.newFixedThreadPool(10);
        executor.submit(customer);
        // 假设有10个人在不停的拨打电话
        for (int i = 0; i < _USER; i++) 
            Productor productor = new Productor(i + "", users);
            executor.submit(productor);
        
        executor.shutdown();
    

用户2已经接入客服
用户6已经接入客服
用户5已经接入客服
通话时长4分钟
用户7已经接入客服
通话时长5分钟
用户4已经接入客服
通话时长4分钟
用户1已经接入客服
通话时长4分钟
用户1已经离开……,还有2个人在连线
用户3已经接入客服
用户0已经接入客服
通话时长3分钟
通话时长4分钟
用户0已经离开……,还有6个人在连线
客服正忙，请稍后再拨…..
用户8已经接入客服
通话时长3分钟
通话时长0分钟
用户6已经接入客服
通话时长2分钟
通话时长5分钟
用户2已经离开……,还有5个人在连线
用户3已经离开……,还有6个人在连线
用户4已经离开……,还有5个人在连线
用户5已经离开……,还有4个人在连线
用户6已经离开……,还有3个人在连线
用户7已经离开……,还有2个人在连线
用户8已经离开……,还有1个人在连线
用户6已经离开……,还有0个人在连线