java初阶多线程5

1.  BlockingQueue 相关

 

- 概念： BlockingQueue 是Java并发包中的一个接口，它支持阻塞的插入和移除操作。当队列满时，插入操作会阻塞等待空间可用；当队列空时，移除操作会阻塞等待元素可用 。

- 优点

- 减少资源竞争，提升效率：通过阻塞机制，避免了线程不断轮询队列状态，减少了CPU资源浪费，提高了整体效率。

- 降低耦合：生产者和消费者之间通过队列进行通信，解耦了两者之间的直接依赖关系。

- 错峰平谷：可以在生产和消费速度不均衡时，缓冲数据，平滑流量。

- 缺点

- 系统更复杂：引入阻塞队列增加了系统的逻辑复杂度，需要考虑队列满、空时的阻塞情况等。

- 引入队列的函数太多，会增加网络开销：如果频繁在网络环境下使用队列相关操作，可能会带来额外的网络流量开销。

- 示例代码

 

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.LinkedBlockingQueue;

 

public class BlockingQueueExample {

    public static void main(String[] args) {

        BlockingQueue<String> queue = new LinkedBlockingQueue<>(3);

 

        Thread producer = new Thread(() -> {

            try {

                queue.put("element1");

                queue.put("element2");

                queue.put("element3");

                // 此时队列已满，继续put会阻塞

                queue.put("element4"); 

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        });

 

        Thread consumer = new Thread(() -> {

            try {

                System.out.println(queue.take());

                System.out.println(queue.take());

                System.out.println(queue.take());

                // 此时队列已空，继续take会阻塞

                System.out.println(queue.take()); 

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        });

 

        producer.start();

        consumer.start();

    }

}

 

 

2. 线程池（ ThreadPoolExecutor ）

 

- 概念：线程池是一种多线程处理形式，处理过程中将任务提交给线程池，而不是直接创建线程执行任务。它维护了一个线程队列，可复用线程来执行任务，提高了线程的利用率和程序性能 。

- 优点

- 降低资源消耗：通过复用线程，减少了线程创建和销毁的开销，降低了系统资源消耗。

- 提高响应速度：当有新任务到达时，无需等待线程创建，可直接从线程池中获取空闲线程执行任务，提高了响应速度。

- 便于管理：可以对线程池中的线程进行统一管理，如设置线程数量上限、线程存活时间等，方便控制并发量和资源使用。

- 缺点

- 线程池大小难以精确设置：如果线程池大小设置过小，可能导致任务堆积，处理效率低下；如果设置过大，会占用过多系统资源，甚至导致系统崩溃。

- 任务队列可能产生溢出：当任务提交速度过快，超过线程池处理能力和任务队列容量时，任务队列可能溢出，导致任务丢失或异常。

- 构造参数

-  corePoolSize ：核心线程数，线程池维护的最小线程数量，即使这些线程处于空闲状态，也不会被销毁。

-  maximumPoolSize ：最大线程数，线程池允许创建的最大线程数量。当任务队列满且有新任务到达时，会创建额外线程，直到达到最大线程数。

-  keepAliveTime ：线程空闲时间，当线程数大于核心线程数时，多余的空闲线程在等待新任务时的存活时间，超过这个时间将被销毁。

-  unit ： keepAliveTime 的时间单位。

-  workQueue ：任务队列，用于存储等待执行的任务。常见的有 ArrayBlockingQueue 、 LinkedBlockingQueue 等 。

-  threadFactory ：线程工厂，用于创建线程，可自定义线程的名称、优先级等属性。

-  handler ：拒绝策略，当任务队列满且线程数达到最大线程数时，新任务的处理策略。常见的拒绝策略有 AbortPolicy （抛出异常）、 CallerRunsPolicy （在调用者线程中执行任务）、 DiscardOldestPolicy （丢弃队列中最老的任务）、 DiscardPolicy （直接丢弃任务） 。

- 示例代码

 

import java.util.concurrent.*;

 

public class ThreadPoolExecutorExample {

    public static void main(String[] args) {

        ThreadPoolExecutor executor = new ThreadPoolExecutor(

                2, 

                4, 

                60, 

                TimeUnit.SECONDS, 

                new LinkedBlockingQueue<>(5), 

                new ThreadPoolExecutor.AbortPolicy()

        );

 

        for (int i = 0; i < 10; i++) {

            executor.submit(() -> {

                try {

                    Thread.sleep(1000);

                    System.out.println("Task executed in thread: " + Thread.currentThread().getName());

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

            });

        }

 

        executor.shutdown();

    }

}

 

 

3. 生产者 - 消费者模型

 

- 概念：生产者 - 消费者模型是通过一个容器（如阻塞队列）来解决生产者和消费者的强耦合问题。生产者生产数据放入容器，消费者从容器中取出数据进行处理，两者无需直接交互 。

- 优点

- 解耦：生产者和消费者之间通过容器间接通信，降低了两者的耦合度。

- 支持并发：生产者和消费者可以并发执行，提高了系统的吞吐量。

- 错峰平谷：可以缓冲生产和消费速度的差异，在生产速度快时积累数据，在消费速度快时消耗积累的数据 。

- 缺点

- 增加系统复杂度：引入了容器和相关的同步控制逻辑，增加了系统的设计和实现复杂度。

- 可能出现资源竞争：如果对容器的操作没有正确同步，可能会出现资源竞争问题，导致数据不一致等错误 。

- 示例代码（基于 BlockingQueue 实现）

 

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.LinkedBlockingQueue;

 

class Producer implements Runnable {

    private BlockingQueue<String> queue;

    public Producer(BlockingQueue<String> queue) {

        this.queue = queue;

    }

    @Override

    public void run() {

        try {

            queue.put("product1");

            queue.put("product2");

            queue.put("product3");

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    }

}

 

class Consumer implements Runnable {

    private BlockingQueue<String> queue;

    public Consumer(BlockingQueue<String> queue) {

        this.queue = queue;

    }

    @Override

    public void run() {

        try {

            System.out.println(queue.take());

            System.out.println(queue.take());

            System.out.println(queue.take());

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    }

}

 

public class ProducerConsumerExample {

    public static void main(String[] args) {

        BlockingQueue<String> queue = new LinkedBlockingQueue<>(3);

        Thread producerThread = new Thread(new Producer(queue));

        Thread consumerThread = new Thread(new Consumer(queue));

 

        producerThread.start();

        consumerThread.start();

 

        try {

            producerThread.join();

            consumerThread.join();

        } catch (InterruptedException e) {e.printStackTrace();

        }

    }

}