多线程与高并发8-线程池1

最新推荐文章于 2023-06-27 09:07:08 发布

原创最新推荐文章于 2023-06-27 09:07:08 发布 · 186 阅读

0 ·

CC 4.0 BY-SA版权

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

10 篇文章

订阅专栏

本文深入探讨Java并发编程的关键概念，包括Executor、ExecutorService、ThreadPoolExecutor的层级关系，Callable与Runnable的区别，FutureTask的双重角色，以及CompletableFuture的多任务管理能力。同时，解析了线程池内部结构和参数配置，对比了ThreadPoolExecutor与ForkJoinPool的适用场景。

Executor、 ExecutorService、ThreadPoolExecutor

Executor：定义并运行线程
ExecutorService：继承于Executor。扩展了executor接口。实现了控制线程的声明周期
ThreadPoolExecutor：线程池

Executor->ExecutorService->ThreadPoolExecutor

Callable

同Runnable一样也是用来执行的，但是callable拥有返回值，可以不用在线程池等待。
一般联合线程池和future使用，submit（）方法传入Callable对象，返回值为future。
submit之后是一个异步过程，并不阻塞。
future.get()方法是一个阻塞的过程，等待取到返回值

Callable<String> call = new Callable(){
	@Override
	public String call() throws Exception{
		return "hello";
	}
}
ExecutorService service = Executors.newCachedThreadPool();
Future<String> future = service.submit(call);//异步过程
System.out.println(future.get());
service.shutdown();

FutureTask

既可以作为一个任务，也可以作为future。在执行完任务后，将返回值直接存到Future中。
（底层实现，FutureTask实现了RunnableFuture，RunnableFuture继承了Runnable和Future）

FutureTask<Integer> task = new FutureTask<>(()->{
	return 1000;
});//等同于runnable，可以直接传入thread，更加灵活
new Thread(task).start();
System.out.println(task.get());//阻塞

CompletableFuture

多任务管理
异步执行，等待所有返回结果，或任意一个返回结果后继续执行

//
CompletableFuture<Double> f1 = CompletableFuture.supplyAsync(()->test1());//异步执行
CompletableFuture<Double> f2 = CompletableFuture.supplyAsync(()->test2());
CompletableFuture<Double> f3 = CompletableFuture.supplyAsync(()->test3());
//所有的的Cfuture执行完毕，再继续执行
CompletableFuture.allof(f1,f2,f3).join();
//有一个的Cfuture执行完毕，再继续执行
CompletableFuture.anyof(f1,f2,f3).join();

可以放到List<CompletableFuture<Double>>  然后循环集合，分别join元素，获取元素

ThreadPoolExecutor、ForkJoinPool

ThreadPoolExecutor：普通线程池
ForkJoinPool：分解汇总任务
用很少的线程可以执行很多的任务（子任务），TPE无法做到先执行子任务
CPU密集型

ThreadPoolExecutor

线程池内部结构，是两个集合。一个集合维护线程，一个集合维护任务。
手工声明线程池的七个小矮人

 public ThreadPoolExecutor(int corePoolSize,//核心线程，核心线程一直存活
                              int maximumPoolSize,//最大线程
                              long keepAliveTime,//存活时间，超过存活时间的线程归还OS，直到只剩下核心线程
                              TimeUnit unit,//时间单位
                              BlockingQueue<Runnable> workQueue,//阻塞队列，blockq,传入不同blockq产生不同线程池
                              ThreadFactory threadFactory,//线程工厂生成线程，
                              RejectedExecutionHandler handler)//拒绝策略。核心线程满载，任务队列（Block）满载，最大线程数满载，执行拒绝策略
//ThreadPoolExecutor提供的四种拒绝策略                              
//abort:抛异常
//Discard:扔掉，不抛异常
//DiscardOldest:扔掉排队时间最久的
//CallerRuns:调用线程池线程的线程处理任务    
//自定义拒绝策略，将未处理线程进行存储（redis,kafka,mysql），之后消费者去抓紧处理（实现RejectedExecutionHandler）

	//threadfactory
	  public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r,
                                  namePrefix + threadNumber.getAndIncrement(),//atomic原子类
                                  0);
            if (t.isDaemon())
                t.setDaemon(false);//设置非守护线程
            if (t.getPriority() != Thread.NORM_PRIORITY)
                t.setPriority(Thread.NORM_PRIORITY);//执行级别，普通级别
            return t;
        }