java 队列线程安全

原创

mob64ca12e4d52e 2023-09-07 16:29:57 ©著作权

文章标签 线程安全 Java java 文章分类 Java 后端开发

©著作权归作者所有：来自51CTO博客作者mob64ca12e4d52e的原创作品，请联系作者获取转载授权，否则将追究法律责任

Java 队列的线程安全性

在多线程编程中，保证数据的安全性是一个非常重要的问题。当多个线程同时对同一个数据进行读写操作时，容易出现数据竞争和不一致的问题。为了解决这个问题，Java 提供了一些线程安全的数据结构，其中之一就是队列（Queue）。

什么是队列？

队列是一种线性数据结构，它遵循先进先出（FIFO）的原则。在队列中，新元素插入的一端称为队尾，已有元素的删除发生在队列的另一端，即队头。队列通常用于实现任务调度、消息传递等场景。

队列的实现方式

在 Java 中，队列的实现方式有很多种，包括数组、链表等。每种实现方式都有其各自的优缺点，但无论哪种方式，都需要考虑到线程安全性。

ArrayBlockingQueue

ArrayBlockingQueue 是 Java 中的一个阻塞队列实现，它基于数组实现，具有固定容量。它的插入和删除操作都是原子的，并且内部使用了锁来保证线程安全。

import java.util.concurrent.ArrayBlockingQueue;

public class ArrayBlockingQueueExample {
    public static void main(String[] args) {
        ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);

        // 生产者线程
        Thread producerThread = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    queue.put(i);
                    System.out.println("Producer: " + i);
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // 消费者线程
        Thread consumerThread = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    int value = queue.take();
                    System.out.println("Consumer: " + value);
                    Thread.sleep(2000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        producerThread.start();
        consumerThread.start();
    }
}

上述代码中，我们创建了一个容量为 10 的 ArrayBlockingQueue 对象，并使用两个线程模拟生产者和消费者的行为。生产者线程往队列中放入元素，消费者线程从队列中取出元素，它们之间是通过队列进行交互的。

ConcurrentLinkedQueue

ConcurrentLinkedQueue 是 Java 中的一个非阻塞队列实现，它基于链表实现，没有容量限制。它采用一种乐观锁的策略，通过 CAS（Compare and Swap）操作来保证线程安全。

import java.util.concurrent.ConcurrentLinkedQueue;

public class ConcurrentLinkedQueueExample {
    public static void main(String[] args) {
        ConcurrentLinkedQueue<Integer> queue = new ConcurrentLinkedQueue<>();

        // 生产者线程
        Thread producerThread = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    queue.offer(i);
                    System.out.println("Producer: " + i);
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // 消费者线程
        Thread consumerThread = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    Integer value = queue.poll();
                    if (value != null) {
                        System.out.println("Consumer: " + value);
                    }
                    Thread.sleep(2000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        producerThread.start();
        consumerThread.start();
    }
}

上述代码中，我们创建了一个 ConcurrentLinkedQueue 对象，并使用两个线程模拟生产者和消费者的行为。它们之间同样通过队列进行交互。