Verwendung der Java-Thread-Warteschlange – ConcurrentLinkedQueue

ConcurrentLinkedQueue ist eine nicht blockierende Warteschlange, die auf einer verknüpften Liste basiert. Sie verwendet den CAS-Algorithmus, um Thread-Sicherheit zu gewährleisten, und bietet eine höhere Leistung als blockierende Warteschlangen. Es handelt sich um eine unbegrenzte Warteschlange und Elemente können unbegrenzt zur Warteschlange hinzugefügt werden. Es handelt sich um eine FIFO-Warteschlange (First In, First Out), das heißt, zuerst hinzugefügte Elemente werden zuerst abgerufen.

ConcurrentLinkedQueue kann verwendet werden, um Szenarien mit hoher Parallelität zu erreichen, z. B. wenn sich mehrere Threads eine Aufgabenwarteschlange teilen. Der folgende Code erstellt beispielsweise eine ConcurrentLinkedQueue und fügt ihr 10 Aufgaben hinzu. Anschließend werden drei Threads erstellt, um Aufgaben aus der Warteschlange abzurufen und auszuführen.

import java.util.concurrent.ConcurrentLinkedQueue;

// 定义一个任务类
class Task {
    // 任务名称
    private String name;

    // 构造方法，传入任务名称
    public Task(String name) {
        this.name = name;
    }

    // 执行任务的方法
    public void execute() {
        System.out.println(Thread.currentThread().getName() + " is executing task: " + name);
    }
}

public class ConcurrentLinkedQueueDemo {
    public static void main(String[] args) {
        // 创建一个并发链表队列
        ConcurrentLinkedQueue<Task> clq = new ConcurrentLinkedQueue<>();
        // 向队列中添加10个任务
        for (int i = 0; i < 10; i++) {
            clq.offer(new Task("task" + i));
        }
        // 创建三个线程，从队列中获取任务并执行
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                while (!clq.isEmpty()) {
                    Task task = clq.poll();
                    if (task != null) {
                        task.execute();
                    }
                }
            }, "thread" + i).start();
        }
    }
}

Ausgabe (kann variieren):

thread0 is executing task: task0
thread1 is executing task: task1
thread2 is executing task: task2
thread0 is executing task: task3
thread1 is executing task: task4
thread2 is executing task: task5
thread0 is executing task: task6
thread1 is executing task: task7
thread2 is executing task: task8
thread0 is executing task: task9

Es ist ersichtlich, dass die drei Threads gleichzeitig Aufgaben aus der Warteschlange abrufen und diese ohne Datenverlust oder Verwirrung ausführen.