多线程和高并发(六)

最新推荐文章于 2022-04-14 15:29:23 发布

wardseptember

最新推荐文章于 2022-04-14 15:29:23 发布

阅读量189

点赞数

分类专栏：多线程和高并发文章标签：线程池 Java 阻塞队列

本文链接：https://blog.csdn.net/wardseptember/article/details/111117241

版权

多线程和高并发专栏收录该内容

8 篇文章 0 订阅

订阅专栏

阻塞队列

在多线程领域：所谓阻塞，即在某些情况下会挂起线程，一旦条件满足，被挂起的线程又会自动被唤醒。

当阻塞队列是空时，从队列中获取元素的操作将会被阻塞
当阻塞队列是满时，往队列里添加元素的操作将会被阻塞

Queue和List

Queue提供了一些对线程友好的API，Offer、peek、poll

BlockingQueue提供Put take有阻塞的功能

ArrayBlockingQueue

由数组结构组成的有界阻塞队列

LinkedBlockingQueue

由链表结构组成的有界阻塞队列，默认大小为Integer.MAX_VALUE.

实现了生产者消费者模式，queue为空不能取，能往里面加；queue满了只能取，不能添加。

PriorityBlockingQueue

支持优先级排序的无界阻塞队列

DelayQueue

使用优先级队列实现的延迟无界阻塞队列。

java延迟队列提供了在指定时间才能获取队列元素的功能，队列头元素是最接近过期的元素。没有过期元素的话，使用poll()方法会返回null值，超时判定是通过getDelay(TimeUnit.NANOSECONDS)方法的返回值小于等于0来判断。延时队列不能存放空元素。

延时队列实现了Iterator接口，但iterator()遍历顺序不保证是元素的实际存放顺序。

SynchronousQueue

不存储元素的阻塞队列，也即单个元素的队列。

容量为零。等着有人拿，才能往里装，相当于直接递到另一个线程手里，多用于两个线程之间交换数据。

TransferQueue

transferQueue是往queue装数据，然后等着被取走，阻塞着等着。

LinkedTransferQueue

由链表结构组成的无界阻塞队列。

LinkedBlockingDeque

由链表结构组成的双向阻塞队列

使用阻塞队列实现生产者消费者模型

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author wardseptember
 * @create 2020-09-22 14:20
 */
class MyResource {
    private volatile boolean FLAG = true;
    private AtomicInteger atomicInteger = new AtomicInteger();
    BlockingQueue<String> blockingQueue;

    public MyResource(BlockingQueue<String> blockingQueue) {
        this.blockingQueue = blockingQueue;
    }

    public void myProduct() throws Exception {
        String data = null;
        boolean retValue;
        while (FLAG) {
            data = atomicInteger.incrementAndGet() + "";
            retValue = blockingQueue.offer(data, 2L, TimeUnit.SECONDS);
            if (retValue) {
                System.out.println(Thread.currentThread().getName()+"\t 插入队列"+data+"成功");
            } else {
                System.out.println(Thread.currentThread().getName()+"\t 插入队列"+data+"失败");
            }
            TimeUnit.SECONDS.sleep(1);
        }
        System.out.println(Thread.currentThread().getName()+"\t 生成停止");
    }

    public void myConsumer() throws Exception {
        String result = null;
        while (FLAG) {
            result = blockingQueue.poll(2L, TimeUnit.SECONDS);
            if (result == null || result.equalsIgnoreCase("")) {
                FLAG = true;
                System.out.println(Thread.currentThread().getName()+"\t 超过2秒钟没有取到，消费者退出");
                return;
            }
            System.out.println(Thread.currentThread().getName()+"\t 消费队列" + result + "成功");
        }
    }

    public void stop() throws Exception {
        this.FLAG = false;
    }
}
public class BlockingQueueProductConsumer {
    public static void main(String[] args) {
        MyResource myResource = new MyResource(new ArrayBlockingQueue<>(10));
        new Thread(() -> {
            try {
                myResource.myProduct();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "product").start();

        new Thread(() -> {
            try {
                myResource.myConsumer();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "consumer").start();

        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try {
            myResource.stop();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

线程池

Java中的线程池是运用场景最多的并发框架，几乎所有需要异步或并发执行任务的程序都可以使用线程池。在开发过程中，合理地使用线程池能够带来3个好处。

主要特点：线程复用、控制最大并发数和管理线程

降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。

Java的线程既是工作单元，也是执行机制。从JDK 5开始，把工作单元与执行机制分离开来。工作单元包括Runnable和Callable，而执行机制由Executor框架提供。

Executor

在HotSpot VM的线程模型中，Java线程(java.lang.Thread)被一对一映射为本地操作系统线程。Java线程启动时会创建一个本地操作系统线程;当该Java线程终止时，这个操作系统线程也会被回收。操作系统会调度所有线程并将它们分配给可用的CPU。

在上层，Java多线程程序通常把应用分解为若干个任务，然后使用用户级的调度器 (Executor框架)将这些任务映射为固定数量的线程;在底层，操作系统内核将这些线程映射到硬件处理器上。

从图中可以看出，应用程序通过Executor框架控制上层的调度;而下层的调度由操作系统内核控制，下层的调度不受应用程序的控制。

Executor框架主要由3大部分组成如下。

任务。包括被执行任务需要实现的接口:Runnable接口或Callable接口。
任务的执行。包括任务执行机制的核心接口Executor，以及继承自Executor的 ExecutorService接口。Executor框架有两个关键类实现了ExecutorService接口 (ThreadPoolExecutor和ScheduledThreadPoolExecutor)。
异步计算的结果。包括接口Future和实现Future接口的FutureTask类。

简介：

Executor是一个接口，它是Executor框架的基础，它将任务的提交与任务的执行分离开来。
ThreadPoolExecutor是线程池的核心实现类，用来执行被提交的任务。 ·ScheduledThreadPoolExecutor是一个实现类，可以在给定的延迟后运行命令，或者定期执行命令。ScheduledThreadPoolExecutor比Timer更灵活，功能更强大。
Future接口和实现Future接口的FutureTask类，代表异步计算的结果。
Runnable接口和Callable接口的实现类，都可以被ThreadPoolExecutor或Scheduled- ThreadPoolExecutor执行。

主线程首先要创建实现Runnable或者Callable接口的任务对象。工具类Executors可以把一个Runnable对象封装为一个Callable对象(Executors.callable(Runnable task)或 Executors.callable(Runnable task，Object resule))。

然后可以把Runnable对象直接交给ExecutorService执行(ExecutorService.execute(Runnable command));或者也可以把Runnable对象或Callable对象提交给ExecutorService执行(Executor- Service.submit(Runnable task)或ExecutorService.submit(Callable<T>task))。

如果执行ExecutorService.submit(…)，ExecutorService将返回一个实现Future接口的对象 (到目前为止的JDK中，返回的是FutureTask对象)。由于FutureTask实现了Runnable，程序员也可以创建FutureTask，然后直接交给ExecutorService执行。

最后，主线程可以执行FutureTask.get()方法来等待任务执行完成。主线程也可以执行

FutureTask.cancel(boolean mayInterruptIfRunning)来取消此任务的执行。

使用Executor

import java.util.concurrent.Executor;

/**
 * @author wardseptember
 * @create 2020-07-08 12:35
 */
public class MyExecutor implements Executor {
    public static void main(String[] args) {
        new MyExecutor().execute(() -> System.out.println("hello executor"));
    }

    @Override
    public void execute(Runnable command) {
        command.run();
    }
}

使用Callable

import java.util.concurrent.*;

/**
 * @author wardseptember
 * @create 2020-07-08 13:46
 */
public class CallableDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<String> c = new Callable<String>() {
            @Override
            public String call() throws Exception {
                return "hello callable";
            }
        };
        ExecutorService service = Executors.newCachedThreadPool();
        // 异步
        Future<String> future = service.submit(c);
        // 阻塞
        System.out.println(future.get());
        service.shutdown();
    }
}

FutureTask

FutureTask实现了RunnableFuture接口，RunnableFuture继承自Runnable、Future，因此FutureTask可以直接丢给线程运行，并且能获取返回值。

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;

/**
 * @author wardseptember
 * @create 2020-07-08 13:56
 */
public class FutureTaskDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<Integer> task = new FutureTask<>(() -> {
            TimeUnit.SECONDS.sleep(1);
            return 1000;
        });
        // 异步操作
        new Thread(task).start();
        // 阻塞操作
        System.out.println(task.get());
    }
}

Executor框架的成员

Executor框架的主要成员:ThreadPoolExecutor、ScheduledThreadPoolExecutor、 Future接口、Runnable接口、Callable接口和Executors。

ThreadPoolExecutor

ThreadPoolExecutor通常使用工厂类Executors来创建。Executors可以创建3种类型的

ThreadPoolExecutor: SingleThreadExecutor、FixedThreadPool和CachedThreadPool。

ScheduledThreadPoolExecutor

ScheduledThreadPoolExecutor通常使用工厂类Executors来创建。Executors可以创建2种类型的ScheduledThreadPoolExecutor，如下:

ScheduledThreadPoolExecutor，包含若干个线程的ScheduledThreadPoolExecutor。
SingleThreadScheduledExecutor，只包含一个线程的ScheduledThreadPoolExecutor。

Future接口

Future接口和实现Future接口的FutureTask类用来表示异步计算的结果。当我们把Runnable 接口或Callable接口的实现类提交(submit)给ThreadPoolExecutor或 ScheduledThreadPoolExecutor时，ThreadPoolExecuto或ScheduledThreadPoolExecutor会向我们返回一个FutureTask对象。

Runnable接口和Callable接口

Runnable接口和Callable接口的实现类，都可以被ThreadPoolExecutor或Scheduled- ThreadPoolExecutor执行。它们之间的区别是Runnable不会返回结果，而Callable可以返回结果。

除了可以自己创建实现Callable接口的对象外，还可以使用工厂类Executors来把一个 Runnable包装成一个Callable。

CompletableFuture

CompletableFuture管理多个Future结果等等。

ThreadPoolExecutor

Executor框架最核心的类是ThreadPoolExecutor，它是线程池的实现类，主要由下列4个组件构成。

corePool:核心线程池的大小。
maximumPool:最大线程池的大小。
BlockingQueue:用来暂时保存任务的工作队列。
RejectedExecutionHandler:当ThreadPoolExecutor已经关闭或ThreadPoolExecutor已经饱和时(达到了最大线程池大小且工作队列已满)，execute()方法将要调用的Handler。

ThreadPoolExecutor构造方法

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
    if (corePoolSize < 0 ||
        maximumPoolSize <= 0 ||
        maximumPoolSize < corePoolSize ||
        keepAliveTime < 0)
        throw new IllegalArgumentException();
    if (workQueue == null || threadFactory == null || handler == null)
        throw new NullPointerException();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

序号	名称	类型	含义
1	corePoolSize	int	核心线程池大小
2	maximumPoolSize	int	最大线程池大小
3	keepAliveTime	long	线程最大空闲时间
4	unit	TimeUnit	时间单位
5	workQueue	`BlockingQueue<Runnable>`	线程等待队列
6	threadFactory	ThreadFactory	线程创建工厂
7	handler	RejectedExecutionHandler	拒绝策略

线程池对任务处理流程

参数详解

corePoolSize、maximumPoolSize

线程池执行器将会根据corePoolSize和maximumPoolSize自动地调整线程池大小。

当在execute(Runnable)方法中提交新任务并且少于corePoolSize线程正在运行时，即使其他工作线程处于空闲状态，也会创建一个新线程来处理该请求。如果有多于corePoolSize但小于maximumPoolSize线程正在运行，则仅当队列已满时才会创建新线程。

prestartCoreThread

prestartCoreThread 核心线程预启动

在默认情况下，只有当新任务到达时，才开始创建和启动核心线程，但是我们可以使用 prestartCoreThread()和 prestartAllCoreThreads() 方法动态调整。
如果使用非空队列构建池，则可能需要预先启动线程。

方法	作用
prestartCoreThread()	创一个空闲任务线程等待任务的到达
prestartAllCoreThreads()	创建核心线程池数量的空闲任务线程等待任务的到达

ThreadFactory 线程工厂

新线程使用ThreadFactory创建。如果未另行指定，则使用Executors.defaultThreadFactory默认工厂，使其全部位于同一个ThreadGroup中，并且具有相同的NORM_PRIORITY优先级和非守护进程状态。

通过提供不同的ThreadFactory，您可以更改线程的名称，线程组，优先级，守护进程状态等。如果ThreadCactory在通过从newThread返回null询问时未能创建线程，则执行程序将继续，但可能无法执行任何任务。

Keep-alive times 线程存活时间

如果线程池当前拥有超过corePoolSize的线程，那么多余的线程在空闲时间超过keepAliveTime时会被终止 ( 请参阅getKeepAliveTime(TimeUnit) )。这提供了一种在不积极使用线程池时减少资源消耗的方法。

如果池在以后变得更加活跃，则应构建新线程。也可以使用方法setKeepAliveTime(long，TimeUnit)进行动态调整。

防止空闲线程在关闭之前终止，可以使用如下方法：

setKeepAliveTime(Long.MAX_VALUE，TimeUnit.NANOSECONDS);

默认情况下，keep-alive策略仅适用于存在超过corePoolSize线程的情况。但是，只要keepAliveTime值不为零，方法allowCoreThreadTimeOut(boolean)也可用于将此超时策略应用于核心线程。

`BlockingQueue

BlockingQueu用于存放提交的任务，队列的实际容量与线程池大小相关联。

如果当前线程池任务线程数量小于核心线程池数量，执行器总是优先创建一个任务线程，而不是从线程队列中取一个空闲线程。
如果当前线程池任务线程数量大于核心线程池数量，执行器总是优先从线程队列中取一个空闲线程，而不是创建一个任务线程。

如果当前线程池任务线程数量大于核心线程池数量，且队列中无空闲任务线程，将会创建一个任务线程，直到线程数量等于maximumPoolSize；如果线程数量等于maximumPoolSize，线程池无空闲线程，且队列是满的，则任务将会被拒绝。

主要有三种队列策略：

1. **Direct handoffs 直接握手队列**
   Direct handoffs 的一个很好的默认选择是 SynchronousQueue，它将任务交给线程而不需要保留。这里，如果没有线程立即可用来运行它，那么排队任务的尝试将失败，因此将构建新的线程。
   此策略在处理可能具有内部依赖关系的请求集时避免锁定。Direct handoffs 通常需要无限制的maximumPoolSizes来避免拒绝新提交的任务。 **但得注意，当任务持续以平均提交速度大余平均处理速度时，会导致线程数量会无限增长问题。**
2. Unbounded queues 无界队列**
   当所有corePoolSize线程繁忙时，使用无界队列（例如，没有预定义容量的LinkedBlockingQueue）将导致新任务在队列中等待，从而导致maximumPoolSize的值没有任何作用。当每个任务互不影响，完全独立于其他任务时，这可能是合适的; 例如，在网页服务器中， 这种队列方式可以用于平滑瞬时大量请求。**但得注意，当任务持续以平均提交速度大余平均处理速度时，会导致队列无限增长问题。**
3. **Bounded queues 有界队列**
   一个有界的队列（例如，一个ArrayBlockingQueue）和有限的maximumPoolSizes配置有助于防止资源耗尽，但是难以控制。队列大小和maximumPoolSizes需要 **相互权衡**：

使用大队列和较小的maximumPoolSizes可以最大限度地减少CPU使用率，操作系统资源和上下文切换开销，但会导致人为的低吞吐量。如果任务经常被阻塞（比如I/O限制），那么系统可以调度比我们允许的更多的线程。
使用小队列通常需要较大的maximumPoolSizes，这会使CPU更繁忙，但可能会遇到不可接受的调度开销，这也会降低吞吐量。

Rejected tasks 拒绝任务
拒绝任务有两种情况：1. 线程池已经被关闭；2. 任务队列已满且maximumPoolSizes已满；
无论哪种情况，都会调用RejectedExecutionHandler的rejectedExecution方法。预定义了四种处理策略：
1. AbortPolicy：默认的策略，抛出RejectedExecutionException运行时异常；
2. CallerRunsPolicy：在任务被拒绝添加后，会调用当前线程池的所在的线程去执行被拒绝的任务；
3. DiscardPolicy：直接丢弃新提交的任务；
4. DiscardOldestPolicy：如果执行器没有关闭，队列头的任务将会被丢弃，然后执行器重新尝试执行任务（如果失败，则重复这一过程）；
  我们可以自己定义RejectedExecutionHandler，以适应特殊的容量和队列策略场景
Hook methods 钩子方法

ThreadPoolExecutor为提供了每个任务执行前后提供了钩子方法，重写beforeExecute(Thread，Runnable)和afterExecute(Runnable，Throwable)方法来操纵执行环境；例如，重新初始化ThreadLocals，收集统计信息或记录日志等。此外，terminated()在Executor完全终止后需要完成后会被调用，可以重写此方法，以执行任殊处理。
注意：如果hook或回调方法抛出异常，内部的任务线程将会失败并结束。

Queue maintenance 维护队列

getQueue()方法可以访问任务队列，一般用于监控和调试。绝不建议将这个方法用于其他目的。当在大量的队列任务被取消时，remove()和purge()方法可用于回收空间。

Finalization 关闭

如果程序中不在持有线程池的引用，并且线程池中没有线程时，线程池将会自动关闭。如果您希望确保即使用户忘记调用 shutdown()方法也可以回收未引用的线程池，使未使用线程最终死亡。那么必须通过设置适当的 keep-alive times 并设置allowCoreThreadTimeOut(boolean) 或者使 corePoolSize下限为0 。

一般情况下，线程池启动后建议手动调用shutdown()关闭。

自定义线程池

import java.io.IOException;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author wardseptember
 * @create 2020-07-08 14:54
 */
public class ThreadPoolExecutorDemo {
    public static void main(String[] args) throws IOException {
        int corePoolSize = 2;
        int maxmunPoolSize = 4;
        long keepAliveTime = 10;
        TimeUnit unit = TimeUnit.SECONDS;
        ArrayBlockingQueue<Runnable> blockingDeque = new ArrayBlockingQueue<>(2);
        ThreadFactory threadFactory = new NameThreadFactory();
        RejectedExecutionHandler handler = new MyIgnorePolicy();
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(corePoolSize, maxmunPoolSize, keepAliveTime,
                unit, blockingDeque, threadFactory, handler);
        // 预启动所有核心线程
        // threadPoolExecutor.prestartAllCoreThreads();
        for (int i = 1; i <= 10; ++i) {
            MyTask task = new MyTask(String.valueOf(i));
            threadPoolExecutor.execute(task);
        }
        // 阻塞主线程
        System.in.read();
        threadPoolExecutor.shutdown();
    }
    static class NameThreadFactory implements ThreadFactory {
        private final AtomicInteger atomicInteger = new AtomicInteger(1);

        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r, "my-thread-" + atomicInteger.getAndIncrement());
            System.out.println(t.getName() + "被创建");
            return t;
        }
    }

    public static class MyIgnorePolicy implements RejectedExecutionHandler {
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            doLog(r, executor);
        }
        private void doLog(Runnable r, ThreadPoolExecutor executor) {
            System.out.println(r.toString() + "被拒绝");
        }
    }
    static class MyTask implements Runnable {
        private String name;

        public MyTask(String name) {
            this.name = name;
        }

        @Override
        public void run() {
            try {
                System.out.println(this.toString() + "正在运行");
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        public String getName() {
            return name;
        }

        @Override
        public String toString() {
            return "MyTask [name=" + name + "]";
        }
    }
}

运行结果

my-thread-1被创建
my-thread-2被创建
my-thread-3被创建
my-thread-4被创建
MyTask [name=2]正在运行
MyTask [name=1]正在运行
MyTask [name=5]正在运行
MyTask [name=6]正在运行
MyTask [name=7]被拒绝
MyTask [name=8]被拒绝
MyTask [name=9]被拒绝
MyTask [name=10]被拒绝
MyTask [name=3]正在运行
MyTask [name=4]正在运行

按照上面的三条规则可以知道，1、2任务来时直接创建核心线程处理，当3、4任务来时并不会直接创建线程处理，而是进入阻塞队列，当阻塞队列慢时，且核心线程没有空闲，则会创建非核心线程，所以可以看到5、6任务正在运行；当线程数达到最大值，且所有线程都在忙碌，阻塞队列也是满的，则会直接拒绝任务，调用RejectedExecutionHandler。

参考链接

徐志毅

wardseptember

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
多线程和高并发(六)

阻塞队列在多线程领域：所谓阻塞，即在某些情况下会挂起线程，一旦条件满足，被挂起的线程又会自动被唤醒。当阻塞队列是空时，从队列中获取元素的操作将会被阻塞当阻塞队列是满时，往队列里添加元素的操作将会被阻塞Queue和ListQueue提供了一些对线程友好的API，Offer、peek、pollBlockingQueue提供Put take有阻塞的功能ArrayBlockingQueue由数组结构组成的有界阻塞队列LinkedBlockingQueue由链表结构组成的有界阻塞队列，默认
复制链接

扫一扫