Java高手的30k之路｜面试宝典｜精通BlockingQueue常用实现类

最新推荐文章于 2024-07-19 17:37:28 发布
最新推荐文章于 2024-07-19 17:37:28 发布
阅读量1.2k 收藏 30
点赞数 28
分类专栏： Java高手的30k之路 面试攻略 JAVA 文章标签： java 面试 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41379244/article/details/139724145
版权

BlockingQueue

BlockingQueue 是 Java 并发包 (java.util.concurrent) 提供的一个接口，用于支持线程安全的队列操作。它特别适用于生产者-消费者模式，提供了阻塞的插入和移除操作。当队列为空时，获取操作将阻塞等待；当队列已满时，插入操作将阻塞等待。

主要特点

  1. 线程安全：
    • BlockingQueue 实现了线程安全的队列操作，确保在多线程环境下的安全性。
  2. 阻塞操作：
    • 提供了阻塞的插入、移除和检查操作，适用于需要等待队列变为非空或非满的场景。
  3. 可选超时：
    • 可以设置操作的超时时间，当超时到达后操作会自动放弃。

常用实现类

  1. ArrayBlockingQueue：
    • 基于数组的有界阻塞队列，容量固定，插入和移除操作需要锁定整个队列。
  2. LinkedBlockingQueue：
    • 基于链表的阻塞队列，默认容量为 Integer.MAX_VALUE，可以指定容量，插入和移除操作锁定独立节点。
  3. PriorityBlockingQueue：
    • 基于优先级堆的无界阻塞队列，元素按优先级排序。
  4. DelayQueue：
    • 基于优先级堆的无界阻塞队列，元素带有延迟时间，只有延迟期满时才能从队列中取出。
  5. SynchronousQueue：
    • 没有容量的阻塞队列，每个插入操作必须等待相应的移除操作，反之亦然。

ArrayBlockingQueue

ArrayBlockingQueue 是 Java 并发包 (java.util.concurrent) 中的一个线程安全的有界阻塞队列实现。它使用数组作为内部数据结构，并支持在多线程环境下进行高效的生产者-消费者模式操作。

主要特点

  1. 有界队列：

    • ArrayBlockingQueue 是有界的，在初始化时需要指定队列的容量。当队列满时，插入操作会被阻塞，直到有空间可用。

  2. 线程安全：

    • 通过内部锁（ReentrantLock）和条件变量（Condition）实现线程安全的入队和出队操作。

  3. 先进先出 (FIFO)：

    • 队列遵循先进先出 (FIFO) 原则，先插入的元素先被移除。

使用场景

ArrayBlockingQueue 适用于以下场景：

  1. 生产者-消费者模式：

    • 生产者线程向队列中添加元素，消费者线程从队列中取元素。通过阻塞机制，可以有效协调生产者和消费者的速度。

  2. 限流和缓冲：

    • 可以用来实现限流，防止生产者生产速度过快导致系统过载。也可以用作缓冲区，在多个线程之间传递数据。

  3. 多线程环境中的任务调度：

    • 适用于需要在多个线程之间调度任务的场景，如线程池。

示例代码

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

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

        // 生产者线程
        Thread producer = new Thread(() -> {
            try {
                for (int i = 0; i < 20; i++) {
                    queue.put(i);
                    System.out.println("Produced: " + i);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        // 消费者线程
        Thread consumer = new Thread(() -> {
            try {
                while (true) {
                    Integer value = queue.take();
                    System.out.println("Consumed: " + value);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        producer.start();
        consumer.start();

        producer.join();
        consumer.join();
    }
}

性能分析

  • 插入和删除操作：插入 (put) 和删除 (take) 操作的时间复杂度为 O(1)，在绝大多数情况下具有很好的性能。
  • 阻塞操作：当队列为空时，消费者线程会被阻塞；当队列满时，生产者线程会被阻塞。这种阻塞机制有效地控制了线程间的协作。
  • 内存开销：由于使用数组作为内部存储结构，内存开销较小。但是需要在初始化时指定容量，并且容量不能动态扩展。

注意事项

  1. 容量限制：

    • ArrayBlockingQueue 是有界队列，初始化时必须指定容量。如果容量过小，可能会导致生产者频繁阻塞；如果容量过大，可能会占用过多内存。

  2. 阻塞操作：

    • 阻塞操作会使线程进入等待状态，在使用时需要考虑到可能的线程阻塞问题，防止发生死锁或线程饥饿。

  3. 性能：

    • 由于内部使用锁机制，ArrayBlockingQueue 在高并发情况下可能会有一定的性能开销。对于无界队列或者需要更高并发性能的场景，可以考虑使用 ConcurrentLinkedQueue。

总结

ArrayBlockingQueue 是一个适用于多线程环境中的有界阻塞队列，提供了高效的生产者-消费者模式实现。它通过先进先出 (FIFO) 原则和内部锁机制，保证了队列操作的线程安全性。适用于需要限流、缓冲和多线程任务调度的场景。

Condition

条件变量 (Condition) 是 Java 中用于线程间协调的重要机制之一。它是 Java 并发包 (java.util.concurrent) 中 Lock 接口的一个子接口，允许线程在特定条件下等待和唤醒。条件变量与传统的监视器方法 (wait, notify, notifyAll) 类似，但提供了更高的灵活性和功能。

主要特点

  1. 与锁配合使用：

    • Condition 必须与 Lock 一起使用，一个 Condition 实例总是绑定到一个特定的 Lock 实例。通常是通过 Lock 实例的 newCondition() 方法来创建 Condition 实例。

  2. 等待和唤醒机制：

    • Condition 提供了 await() 方法，使线程可以等待特定的条件满足。
    • signal() 和 signalAll() 方法用于唤醒等待条件的一个或所有线程。

使用场景

条件变量适用于以下场景：

  1. 生产者-消费者模式：

    • 生产者线程向缓冲区添加数据，消费者线程从缓冲区取数据。当缓冲区满时，生产者等待；当缓冲区空时，消费者等待。

  2. 线程同步：

    • 适用于需要线程按照某种顺序执行的场景。

示例代码

以下是一个简单的生产者-消费者模式的示例，展示了 Condition 的使用：

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ProducerConsumer {
    private static final int BUFFER_SIZE = 10;
    private final int[] buffer = new int[BUFFER_SIZE];
    private int count = 0;
    private int putIndex = 0;
    private int takeIndex = 0;
    
    private final Lock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();

    public void produce(int value) throws InterruptedException {
        lock.lock();
        try {
            while (count == BUFFER_SIZE) {
                notFull.await();
            }
            buffer[putIndex] = value;
            putIndex = (putIndex + 1) % BUFFER_SIZE;
            count++;
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }

    public int consume() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0) {
                notEmpty.await();
            }
            int value = buffer[takeIndex];
            takeIndex = (takeIndex + 1) % BUFFER_SIZE;
            count--;
            notFull.signal();
            return value;
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        ProducerConsumer pc = new ProducerConsumer();

        // Producer thread
        new Thread(() -> {
            try {
                for (int i = 0; i < 20; i++) {
                    pc.produce(i);
                    System.out.println("Produced: " + i);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();

        // Consumer thread
        new Thread(() -> {
            try {
                for (int i = 0; i < 20; i++) {
                    int value = pc.consume();
                    System.out.println("Consumed: " + value);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();
    }
}

详细步骤

  1. 创建锁和条件变量：

    • 使用 ReentrantLock 创建一个锁实例。
    • 使用锁的 newCondition() 方法创建两个条件变量：notFull 和 notEmpty。

  2. 生产者线程逻辑：

    • 获取锁，检查缓冲区是否满。
    • 如果缓冲区满，则调用 notFull.await() 使当前线程等待。
    • 插入数据，更新缓冲区状态。
    • 调用 notEmpty.signal() 唤醒等待数据的消费者线程。
    • 释放锁。

  3. 消费者线程逻辑：

    • 获取锁，检查缓冲区是否空。
    • 如果缓冲区空，则调用 notEmpty.await() 使当前线程等待。
    • 取出数据，更新缓冲区状态。
    • 调用 notFull.signal() 唤醒等待空间的生产者线程。
    • 释放锁。

性能分析

  • 等待和唤醒机制：条件变量提供的 await() 和 signal() 方法可以有效地协调多线程间的等待和唤醒，避免了繁忙等待（busy-waiting）带来的 CPU 资源浪费。
  • 锁的开销：使用 ReentrantLock 和 Condition 需要在获取和释放锁时进行相应的开销，但相比繁忙等待，这种开销通常是值得的。

注意事项

  1. 条件检查：在调用 await() 前需要检查条件，以防止虚假唤醒。
  2. 中断处理：await() 方法会响应中断，需要在使用时处理 InterruptedException。
  3. 避免死锁：确保在每个 await() 调用后都有相应的 signal() 或 signalAll() 调用，以防止线程永久等待导致死锁。

总结

条件变量 (Condition) 提供了一种灵活的线程间协调机制，允许线程在特定条件下等待和唤醒。它必须与锁 (Lock) 配合使用，适用于生产者-消费者模式、线程同步等场景。通过合理使用条件变量，可以有效地协调多线程间的协作，提高并发程序的性能和可靠性。

LinkedBlockingQueue

LinkedBlockingQueue 是 Java 并发包 (java.util.concurrent) 提供的一种基于链表实现的阻塞队列。它具有可选的容量限制，可以用于实现生产者-消费者模式，支持并发环境下的高效队列操作。

主要特点

  1. 基于链表实现：

    • 内部使用链表存储元素，不同于基于数组的 ArrayBlockingQueue。

  2. 可选容量限制：

    • 可以在创建时指定容量限制，如果不指定，默认容量为 Integer.MAX_VALUE。

  3. 线程安全：

    • LinkedBlockingQueue 使用了独立的锁来控制插入和移除操作，减少了锁争用，提高了并发性能。

  4. 阻塞操作：

    • 提供阻塞的插入 (put) 和移除 (take) 操作，当队列满或空时相应操作将阻塞。

常用方法

  • put(E e)：将元素插入到队列末尾，如果队列已满，则等待直到有空间。
  • take()：从队列头部移除并返回元素，如果队列为空，则等待直到有元素可用。
  • offer(E e, long timeout, TimeUnit unit)：将元素插入到队列末尾，如果队列已满，则等待指定的时间，如果仍无法插入则返回 false。
  • poll(long timeout, TimeUnit unit)：从队列头部移除并返回元素，如果队列为空，则等待指定的时间，如果仍无元素可用则返回 null。

示例代码

以下是一个使用 LinkedBlockingQueue 实现生产者-消费者模式的示例：

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

public class ProducerConsumerExample {

    private static final int BUFFER_SIZE = 10;
    private static final BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(BUFFER_SIZE);

    public static void main(String[] args) {
        // Producer thread
        new Thread(new Producer()).start();

        // Consumer thread
        new Thread(new Consumer()).start();
    }

    static class Producer implements Runnable {
        @Override
        public void run() {
            try {
                for (int i = 0; i < 20; i++) {
                    queue.put(i);  // Blocks if the queue is full
                    System.out.println("Produced: " + i);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }

    static class Consumer implements Runnable {
        @Override
        public void run() {
            try {
                while (true) {
                    Integer value = queue.take();  // Blocks if the queue is empty
                    System.out.println("Consumed: " + value);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

详细步骤

  1. 创建队列：

    • 使用 LinkedBlockingQueue 创建一个具有固定容量的阻塞队列 queue。

  2. 生产者线程逻辑：

    • 使用 put() 方法将元素插入到队列末尾。如果队列已满，则阻塞直到队列有空闲位置。

  3. 消费者线程逻辑：

    • 使用 take() 方法从队列头部移除元素。如果队列为空，则阻塞直到队列有可用元素。

性能分析

  • 高并发性：由于 LinkedBlockingQueue 使用了独立的锁来控制插入和移除操作，可以减少锁争用，提高并发性能。
  • 灵活性：可以根据需要设置容量限制，灵活控制队列大小。

注意事项

  1. 容量限制：

    • 对于有界队列，需要合理设置容量以避免频繁的阻塞和等待。

  2. 异常处理：

    • 阻塞操作会响应中断，需要处理 InterruptedException。

  3. 性能开销：

    • 阻塞队列在高并发环境下可能会引入锁竞争，需要在设计时考虑性能影响。

总结

LinkedBlockingQueue 是 Java 并发编程中的一个重要工具，提供了基于链表的线程安全阻塞队列操作。通过合理使用 LinkedBlockingQueue，可以有效地实现生产者-消费者模式，确保多线程环境下的安全性和高效性。不同于基于数组的 ArrayBlockingQueue，LinkedBlockingQueue 在插入和移除操作上使用独立锁，可以在高并发环境下提供更好的性能。

PriorityBlockingQueue

PriorityBlockingQueue 是 Java 并发包 (java.util.concurrent) 中提供的一个基于优先级堆的线程安全队列。它是一种无界的阻塞队列，支持对元素进行自然顺序或自定义顺序的优先级排序。

主要特点

  1. 基于堆实现：

    • 内部采用二叉堆（通常是最小堆）来维护元素的优先级顺序。

  2. 无界队列：

    • 没有容量限制，队列的大小只受限于可用的内存量。

  3. 线程安全：

    • 支持并发访问，通过内部锁机制实现线程安全。

  4. 优先级排序：

    • 元素按自然顺序（或通过自定义比较器指定的顺序）排序。

  5. 阻塞操作：

    • 提供阻塞的插入 (put) 和移除 (take) 操作，当队列为空时相应操作将阻塞。

常用方法

  • put(E e)：将元素插入队列。对于 PriorityBlockingQueue，该方法等同于 offer(E e)，因为它是无界的。
  • take()：从队列中移除并返回优先级最高的元素，如果队列为空，则等待直到有元素可用。
  • offer(E e, long timeout, TimeUnit unit)：将元素插入队列，等待指定的时间，如果队列无法接受元素则返回 false。
  • poll(long timeout, TimeUnit unit)：从队列中移除并返回优先级最高的元素，等待指定的时间，如果队列为空则返回 null。

示例代码

以下是一个使用 PriorityBlockingQueue 的示例：

import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class PriorityBlockingQueueExample {

    private static final BlockingQueue<Task> queue = new PriorityBlockingQueue<>();

    public static void main(String[] args) {
        // Producer thread
        new Thread(new Producer()).start();

        // Consumer thread
        new Thread(new Consumer()).start();
    }

    static class Task implements Comparable<Task> {
        private final int priority;
        private final String name;

        public Task(int priority, String name) {
            this.priority = priority;
            this.name = name;
        }

        public int getPriority() {
            return priority;
        }

        public String getName() {
            return name;
        }

        @Override
        public int compareTo(Task o) {
            return Integer.compare(this.priority, o.priority);
        }

        @Override
        public String toString() {
            return "Task{name='" + name + "', priority=" + priority + '}';
        }
    }

    static class Producer implements Runnable {
        @Override
        public void run() {
            try {
                for (int i = 0; i < 10; i++) {
                    queue.put(new Task((int) (Math.random() * 10), "Task" + i));
                    System.out.println("Produced: Task" + i);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }

    static class Consumer implements Runnable {
        @Override
        public void run() {
            try {
                while (true) {
                    Task task = queue.take();  // Blocks if the queue is empty
                    System.out.println("Consumed: " + task);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

详细步骤

  1. 创建队列：

    • 使用 PriorityBlockingQueue 创建一个阻塞队列 queue。

  2. 生产者线程逻辑：

    • 使用 put() 方法将元素插入队列。由于 PriorityBlockingQueue 是无界的，put() 方法不会阻塞。

  3. 消费者线程逻辑：

    • 使用 take() 方法从队列中移除并返回优先级最高的元素。如果队列为空，则阻塞直到有可用元素。

性能分析

  • 高并发性：PriorityBlockingQueue 使用内部锁机制来保证线程安全，适用于高并发环境。
  • 优先级处理：基于堆的数据结构提供了高效的优先级排序和检索操作。

注意事项

  1. 无界特性：

    • PriorityBlockingQueue 是无界的，在高负载情况下可能会导致内存占用过多，需要注意容量控制。

  2. 元素排序：

    • 元素需要实现 Comparable 接口或者提供 Comparator 来定义优先级顺序。

  3. 性能开销：

    • 由于使用锁机制来保证线程安全，可能会有一定的性能开销，特别是在高并发情况下。

总结

PriorityBlockingQueue 是 Java 并发编程中的一个重要工具，提供了基于优先级堆的阻塞队列操作。通过合理使用 PriorityBlockingQueue，可以在多线程环境下高效地处理优先级任务调度。它在处理需要优先级排序的任务队列时表现优越，如调度系统、任务管理器等。

DelayQueue

DelayQueue 是 Java 并发包（java.util.concurrent）中的一个实现，用于在一段时间后才能取出元素的阻塞队列。该队列中的元素必须实现 Delayed 接口，并且只有在延迟期满时才能从队列中提取元素。

主要特点

  1. 延迟队列：

    • 元素只有在其延迟时间到期后才能被提取。

  2. 无界队列：

    • 它是无界的，队列的大小仅受限于可用内存量。

  3. 线程安全：

    • 通过内部锁机制实现线程安全。

  4. 基于优先级堆实现：

    • 内部使用优先级堆来存储元素，确保延迟期满的元素总是优先出队。

常用方法

  • put(E e)：将元素插入队列。由于 DelayQueue 是无界的，此方法永远不会阻塞。
  • take()：从队列中取出并移除延迟期满的元素。如果没有延迟期满的元素，则等待。
  • poll(long timeout, TimeUnit unit)：从队列中取出并移除延迟期满的元素，等待指定的时间，如果没有延迟期满的元素，则返回 null。
  • peek()：检索但不移除延迟期满的元素，如果没有这样的元素，则返回 null。

示例代码

以下是一个使用 DelayQueue 的示例：

import java.util.concurrent.Delayed;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.TimeUnit;

public class DelayQueueExample {

    public static void main(String[] args) throws InterruptedException {
        DelayQueue<DelayedTask> queue = new DelayQueue<>();

        // Adding tasks to the DelayQueue
        queue.put(new DelayedTask("Task1", 5, TimeUnit.SECONDS));
        queue.put(new DelayedTask("Task2", 10, TimeUnit.SECONDS));
        queue.put(new DelayedTask("Task3", 1, TimeUnit.MINUTES));

        while (!queue.isEmpty()) {
            DelayedTask task = queue.take();  // This will block until the task's delay has expired
            System.out.println("Executing: " + task.getName());
        }
    }

    static class DelayedTask implements Delayed {
        private final String name;
        private final long startTime;

        public DelayedTask(String name, long delay, TimeUnit unit) {
            this.name = name;
            this.startTime = System.currentTimeMillis() + unit.toMillis(delay);
        }

        public String getName() {
            return name;
        }

        @Override
        public long getDelay(TimeUnit unit) {
            long diff = startTime - System.currentTimeMillis();
            return unit.convert(diff, TimeUnit.MILLISECONDS);
        }

        @Override
        public int compareTo(Delayed o) {
            if (this.startTime < ((DelayedTask) o).startTime) {
                return -1;
            }
            if (this.startTime > ((DelayedTask) o).startTime) {
                return 1;
            }
            return 0;
        }
    }
}

详细步骤

  1. 创建队列：

    • 使用 DelayQueue 创建一个延迟队列 queue。

  2. 定义延迟任务：

    • 创建一个实现 Delayed 接口的任务类 DelayedTask。在这个类中，定义延迟时间和任务名称，并实现 getDelay 和 compareTo 方法。

  3. 添加任务：

    • 使用 put 方法将任务添加到队列中。

  4. 取出并执行任务：

    • 使用 take 方法从队列中取出并移除延迟期满的任务。如果没有延迟期满的任务，take 方法将阻塞直到有任务到期。

性能分析

  • 高并发性：

    • DelayQueue 使用内部锁机制来保证线程安全，适用于高并发环境。

  • 时间复杂度：

    • 插入和移除操作的时间复杂度为 O(log n)，因为内部使用优先级堆进行排序。

注意事项

  1. 无界特性：

    • DelayQueue 是无界的，在高负载情况下可能会导致内存占用过多，需要注意容量控制。

  2. 延迟时间：

    • 队列中的元素必须实现 Delayed 接口，并且延迟时间的计算必须合理准确。

  3. 性能开销：

    • 由于使用锁机制来保证线程安全，可能会有一定的性能开销，特别是在高并发情况下。

总结

DelayQueue 是一个用于在特定延迟时间后才能取出元素的高效阻塞队列。它在需要对任务进行延迟处理的场景中非常有用，如定时任务调度、缓存过期处理等。通过合理使用 DelayQueue，可以在多线程环境下高效地管理延迟任务。

SynchronousQueue

SynchronousQueue 是 Java 并发包（java.util.concurrent）中的一个特殊阻塞队列。与其他阻塞队列不同，SynchronousQueue 不存储元素。每个插入操作必须等待一个对应的移除操作，反之亦然。因此，它适用于需要直接传递数据或任务的高并发场景。

主要特点

  1. 不存储元素：

    • 队列本身不存储任何元素，每个插入操作必须等待一个移除操作，反之亦然。

  2. 适用于传递性设计：

    • 适用于需要在线程之间直接传递数据或任务的场景。

  3. 高并发：

    • 由于没有容量限制，插入和移除操作可以实现高并发性能。

常用方法

  • put(E e)：将元素插入队列。此方法将阻塞，直到另一个线程调用 take 方法移除元素。
  • take()：从队列中移除元素。此方法将阻塞，直到另一个线程调用 put 方法插入元素。
  • offer(E e, long timeout, TimeUnit unit)：尝试在指定时间内将元素插入队列，如果在超时时间内没有配对的移除操作，则返回 false。
  • poll(long timeout, TimeUnit unit)：尝试在指定时间内从队列中移除元素，如果在超时时间内没有配对的插入操作，则返回 null。

示例代码

以下是一个使用 SynchronousQueue 的示例：

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

public class SynchronousQueueExample {

    public static void main(String[] args) {
        SynchronousQueue<String> queue = new SynchronousQueue<>();
        ExecutorService executor = Executors.newFixedThreadPool(2);

        // 生产者
        executor.submit(() -> {
            try {
                System.out.println("Putting item into the queue...");
                queue.put("Hello");
                System.out.println("Item placed into the queue.");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        // 消费者
        executor.submit(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
                System.out.println("Taking item from the queue...");
                String item = queue.take();
                System.out.println("Item taken from the queue: " + item);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        executor.shutdown();
    }
}

详细步骤

  1. 创建队列：

    • 使用 SynchronousQueue 创建一个同步队列 queue。

  2. 创建生产者和消费者：

    • 使用 ExecutorService 创建一个固定大小的线程池，分别提交生产者和消费者任务。
    • 生产者线程尝试将元素放入队列，并阻塞直到消费者线程取走该元素。
    • 消费者线程等待一段时间后，从队列中取出元素。

  3. 启动线程池：

    • 启动线程池，执行生产者和消费者任务。

性能分析

  • 高并发性：

    • SynchronousQueue 由于不存储元素，每个插入和移除操作都必须配对，可以实现高并发性能。

  • 低延迟：

    • 直接传递元素，不需要存储和检索操作，延迟较低。

注意事项

  1. 使用场景：

    • 适用于需要在线程之间直接传递数据或任务的场景，如线程池中的任务提交和执行。

  2. 阻塞行为：

    • 插入和移除操作都是阻塞的，必须确保生产者和消费者线程能够及时配对。

  3. 容量限制：

    • 由于不存储元素，没有容量限制，可能会导致某些线程长时间阻塞，需要合理设计生产者和消费者的配对策略。

总结

SynchronousQueue 是一个用于在线程之间直接传递数据的高效阻塞队列。它在不存储元素的情况下实现了高并发性能，适用于需要直接传递任务或数据的场景。通过合理使用 SynchronousQueue，可以在多线程环境下实现高效的数据传递和任务调度。

BlockingQueue in Spring

在 Spring 中的使用场景

  1. 任务调度和执行：
    • Spring Task Executor：Spring 提供了 TaskExecutor 接口，用于异步任务的执行。常见的实现如 ThreadPoolTaskExecutor，可以通过 BlockingQueue 来管理任务队列，控制线程池的任务调度。
    • Scheduled Tasks：在使用 Spring 的 @Scheduled 注解进行定时任务调度时，可以使用 BlockingQueue 来存储和管理定时任务。
  2. 异步事件处理：
    • ApplicationEvent：在 Spring 事件机制中，可以使用 BlockingQueue 来实现异步事件处理。例如，使用 LinkedBlockingQueue 存储事件，异步处理这些事件，避免主线程阻塞。
  3. 消息队列：
    • Spring Integration：在 Spring Integration 中，可以使用 BlockingQueue 实现内存消息队列，处理消息的发送和接收。例如，使用 QueueChannel 来处理消息的异步传递。

ThreadPoolTaskExecutor 中的 BlockingQueue

ThreadPoolTaskExecutor 使用了 BlockingQueue 来存储待执行的任务。在 Spring 配置中，开发者可以指定不同的 BlockingQueue 实现类来控制任务队列的行为。

ThreadPoolTaskExecutor 源码分析

以下是 ThreadPoolTaskExecutor 的核心部分源码，重点展示了如何使用 BlockingQueue 来管理任务队列：

public class ThreadPoolTaskExecutor extends ExecutorConfigurationSupport implements AsyncListenableTaskExecutor, SchedulingTaskExecutor {

    // 核心线程池大小
    private int corePoolSize = 1;
    // 最大线程池大小
    private int maxPoolSize = Integer.MAX_VALUE;
    // 队列容量
    private int queueCapacity = Integer.MAX_VALUE;
    // 线程池中线程的存活时间（秒）
    private int keepAliveSeconds = 60;
    // 线程池的具体实现
    private ThreadPoolExecutor threadPoolExecutor;

    // 初始化方法
    @Override
    public void afterPropertiesSet() {
        initializeExecutor(threadFactory, rejectedExecutionHandler);
    }

    protected ExecutorService initializeExecutor(ThreadFactory threadFactory, RejectedExecutionHandler rejectedExecutionHandler) {
        BlockingQueue<Runnable> queue = createQueue(this.queueCapacity);
        this.threadPoolExecutor = new ThreadPoolExecutor(
                this.corePoolSize, 
                this.maxPoolSize, 
                this.keepAliveSeconds, 
                TimeUnit.SECONDS, 
                queue, 
                threadFactory, 
                rejectedExecutionHandler);
        return this.threadPoolExecutor;
    }

    protected BlockingQueue<Runnable> createQueue(int queueCapacity) {
        if (queueCapacity > 0) {
            return new LinkedBlockingQueue<>(queueCapacity);
        } else {
            return new SynchronousQueue<>();
        }
    }

    @Override
    public void execute(Runnable task) {
        this.threadPoolExecutor.execute(task);
    }
}
关键部分解析
  1. 核心配置参数：corePoolSize, maxPoolSize, queueCapacity, keepAliveSeconds 这些参数用于配置线程池的行为。
  2. 初始化线程池：initializeExecutor 方法中，创建了一个 BlockingQueue 实例，并用它初始化 ThreadPoolExecutor。
  3. 创建阻塞队列：createQueue 方法根据 queueCapacity 的值决定使用哪种 BlockingQueue 实现。
    • 如果 queueCapacity > 0，则使用 LinkedBlockingQueue。
    • 如果 queueCapacity <= 0，则使用 SynchronousQueue。
window_ye
关注
  • 28
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
码神之路Java面试宝典2022最新版
01-20
这份宝典分为三个部分，分别是《码神之路Java面试宝典（第一版上）》，《码神之路Java面试宝典（第一版中）》和《码神之路Java面试宝典（第一版下）》。 在Java面试中，基础知识是必不可少的。首先，你需要了解Java...
2024 Java面试宝典合集
05-20
这份"2024 Java面试宝典合集"无疑是准备Java求职面试者的宝贵资源。它涵盖了多个关键领域，包括Spring框架、并发编程、Java核心知识以及面试策略等。下面我们将详细探讨这些知识点。 1. **Spring Boot面试题**：...
java工程师高薪面试宝典
02-23
本面试宝典旨在帮助求职者准备Java工程师的面试，提升自己的竞争力，争取到理想的工作薪酬。 首先，Java语言基础是面试中的必备内容。这包括对Java语法的熟练掌握，如类、对象、封装、继承、多态等面向对象编程的...
java并发学习之BlockingQueue实现生产者消费者详解
08-28
"java并发学习之BlockingQueue实现生产者消费者详解" BlockingQueue是Java util.concurrent包下重要的数据结构，提供了线程安全的队列访问方式。在多线程应用中，常用于生产-消费场景。BlockingQueue有多种实现，...
Java程序员面试宝典视频课程之多线程（十一）
06-10
本"Java程序员面试宝典视频课程之多线程（十一）"涵盖了关于多线程的高级主题，旨在帮助学习者掌握面试技巧，提升求职竞争力。 多线程在Java中的应用广泛，它是并发处理和优化程序性能的重要工具。以下是一些核心的...
Java内存模型
最新发布
weixin_44267758的博客
07-19 312
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 576
JVM-垃圾回收与内存分配
day04：Redis和店铺营业状态设置
m0_69266818的博客
07-15 844
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
【Java算法】前缀和 下
2302_79806056的博客
07-18 892
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
【JAVA】相关程序组件
qq_44077764的博客
07-15 167
【JAVA】相关程序组件
Java 中有哪几种基本数据类型？请分别列出它们并简述每种数据类型的特点及其在内存中的占用空间？
liangzai215的专栏
07-15 504
在Java的世界里，数据是构建应用程序的基石。为了高效地处理这些数据，Java设计了一系列基础数据类型，它们直接映射到计算机硬件上，因此在性能和内存使用上更为高效。我们常说的Java八大基本数据类型，涵盖了整数、浮点数、字符和布尔值，下面我将一一介绍它们的特点以及在内存中的占用空间，并通过简单的代码实例来加深理解。
构建自动化的精粹：Gradle任务依赖性与执行顺序控制
liuxin33445566的博客
07-15 561
本文以"构建自动化的精粹：Gradle任务依赖性与执行顺序控制"为题，详细介绍了任务依赖性的重要性、基本配置、多个任务的依赖性、条件依赖性、错误处理、高级用法、多项目构建中的任务依赖性。随着Gradle的不断发展，我们可以预见到更多关于任务依赖性和构建自动化的高级特性的出现，这将进一步扩展Gradle的构建能力，满足更复杂的项目构建需求。任务依赖性定义了任务之间的执行关系，确保了在构建过程中，任务能够按照预期的顺序执行。任务是一个特殊的任务，它默认依赖于所有没有显式排除的任务。方法来指定任务的依赖性。
maven项目容器化运行之1-基于1Panel软件将docker镜像构建能力分享给局域网
qq_37372909的博客
07-15 527
docker核心功能包括镜像的构建和容器的运行，它可以开放端口将镜像构建的能力暴露。docker daeson就是docker的守护进程，开放能力是通过指定docker守护进程监听端口来实现的。后面开发人员就可以通过maven中docker插件来远程调用docker镜像构建能力了。
Java实验2
qq_64727229的博客
07-16 517
类的封装、继承、多态和接口（1）有理数四则运算（2）最终得分
对androidTestDebug 产物进行重新签名
shuizhizhiyin的专栏
07-19 265
在运行 gradle assembleAndroidTestDebug 任务后，自定义的 reSignAndroidTestDebug 任务将会被执行，并对子模块的 androidTestDebug 产物进行重新签名。your_keystore_path.jks、your_keystore_password、your_key_alias 和 your_key_password 需要替换为你的实际路径和密码。如果需要对其他子模块的产物进行重新签名，可以根据需要创建不同的自定义任务。// 设置密钥库密码。
每 日练 习
m0_67187271的博客
07-19 496
正确答案：C 解析：是正确的，这是最基本的类定义形式，没有继承任何类，也没有实现任何接口。也是正确的，这里定义了一个名为x的类，它继承了名为y的类。同样是正确的，这里定义了一个公共类x，它继承了Applet类，这在Java中是合法的，尤其是在创建GUI应用程序时常见。是不正确的，因为在Java中，我们不能使用static关键字来修饰一个类的定义。static关键字只能用于类的方法、变量或者是内部类（即嵌套类），但不能用于顶级类（非嵌套类）。所以，这个选项是错误的。因此，正确答案是C。
《简历宝典》15 - 简历中“项目经历”，实战讲解，Java篇
xingyu_qie的专栏
07-18 177
校招和初级Java开发的项目经历重点是突出自己在实战中的学习。比如对数据库的操作，比如前后端联调工作中遇到问题的解决，比如一些Java基础知识点的逐渐深入掌握，这些都是这个阶段的Java开发需要去不断增强的。和初级前端开发类似，例如你作为一名初级Java开发，负责的是校园图书管理系统的图书信息上传，图书信息管理这个模块的服务端开发，项目经历可以这样编写，如图。
Srping Cloud - @Async注解+Feign手动设置token
qq_36782325的博客
07-16 266
在Spring cloud项目开发中，经常需要通过feign远程调用其他的服务的方法。有时因为跨服务调用的时间较长，就会存在需要异步跨服务调用的场景，此时就会出现请求头（主要是token）丢失的问题。
【利用Selenium+autoIt实现文件上传】
凌飞安
07-16 428
当文件上传功能不能简单修改value属性的时候，你一定要看一下我这片文章。
Java并发编程面试：线程池深度解析
"01.java并发编程面试宝典" 在Java并发编程中，线程池是一个重要的概念，它在面试中经常被提及。线程池可以类比于数据库连接池，两者都提供了一种管理和复用资源的有效方式。线程池的主要目的是减少线程创建和销毁...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值