多线程编程（三）

目录

1. ArrayBlockingQueue

2. 生产者消费者模式

3. 线程池

---

1. ArrayBlockingQueue

由数组支持的有界阻塞队列

package com.company;

import java.util.concurrent.ArrayBlockingQueue;

public class ABQDemo {
    private static ArrayBlockingQueue<Integer> arrayBlockingQueue = new ArrayBlockingQueue<>(10);
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                arrayBlockingQueue.add(i + 1);
            }
        });
        thread1.start();
        try {
            // 等待线程1执行完毕
            thread1.join();
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            // 如果插入失败
            if (!arrayBlockingQueue.offer(11)) {
                System.out.println("插入元素11失败...");
            }
            try {
                //一直阻塞直到插入元素11，注意这里阻塞的不是主线程，main方法还是继续运行
                arrayBlockingQueue.put(11);
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        Thread thread2 = new Thread(() -> {
            Integer element;
            System.out.println("开始出队：");
            while ((element = arrayBlockingQueue.poll()) != null) {
                System.out.print("\t" + element);
            }
        });
        thread2.start();
    }
}

2. 生产者消费者模式

package com.company;

import java.util.Random;
import java.util.concurrent.LinkedBlockingDeque;

public class Main {
    private static LinkedBlockingDeque<Integer> queue = new LinkedBlockingDeque<>();
    public static void main(String[] args) {
        // 生产者
        Thread provider = new Thread(() -> {
            Random random = new Random();
            for (int j = 0; j < 5; j++) {
                try {
                    int i = random.nextInt();
                    queue.put(i);
                    System.out.println("生产数据：" + i);
                    Thread.sleep(1000);
                }
                catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        // 消费者
        Thread consumer = new Thread(() -> {
            Integer data;
            for (int i = 0; i < 5; i++) {
                try {
                    data = queue.take();
                    System.out.println("消费数据：" + data);
                    Thread.sleep(1000);
                }
                catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        provider.start();
        consumer.start();
    }
}

3. 线程池

线程池（thread pool）：一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。

Java 线程池可以通过 Executors 工具类创建，Executors 常用方法：

• newFixedThreadPool(int nThreads): 创建一个固定大小为 n 的线程池
• newSingleThreadExecutor(): 创建只有一个线程的线程池
• newCachedThreadPool(): 创建一个根据需要创建新线程的线程池

// 线程池通过 Executors 工具类创建
package com.company;

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

public class ThreadPoolDemo {
    private static ExecutorService executorService = Executors.newFixedThreadPool(5);
    public static void main(String[] args) {
        executorService.submit(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.print(i + " ");
            }
        });
        //停止线程池 并不会立即关闭 ，而是等线程池中的任务执行完毕后才关闭
        executorService.shutdown();
    }
}

// 直接创建线程池
package com.company;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPoolDemo2 {
    private static ExecutorService executorService = new ThreadPoolExecutor(
            5,   //核心线程数为5
            10,  //最大线程数为10
            0L, TimeUnit.MILLISECONDS,      //非核心线程存活时间
            new LinkedBlockingQueue<>());   //任务队列
    public static void main(String[] args) {
        executorService.submit(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.print(i + " ");
            }
        });
        executorService.shutdown();
    }
}