7. 详解线程池：自定义线程池，JDK自带线程池，ForkJoin，源码解析等(一）

本文链接：https://blog.youkuaiyun.com/weixin_42620966/article/details/119195310

这篇博客深入探讨了并发编程的各种机制和工具，包括`synchronized`、`LockSupport`、`ReentrantLock`、`CountDownLatch`以及自旋锁的概念。同时，介绍了`BlockingQueue`的工作原理，如`put`和`take`方法如何实现线程阻塞。此外，还详细讲解了`Executor`、`ExecutorService`和`ThreadPoolExecutor`在创建和管理线程池中的作用。博客进一步阐述了`Callable`、`Future`以及`FutureTask`在异步任务执行中的应用，并展示了`CompletableFuture`如何优雅地管理多个异步任务的结果。通过实例展示了`CompletableFuture`的使用，包括`allOf`方法等待所有任务完成以及`thenAccept`链式调用来处理结果。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

交替打印1a2v3c4d…

synchronized
LockSupport
ReenrantLock
CountDownLatch || 自旋
CAS

占用CUP
BlockQueue
- 使用put和tack方法，放满了阻塞，取完了阻塞
Exchange

输出谁先执行不一定！！！
transferQueue

把自己的交给对方打印

ThreadPool 线程池

三大类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VzWNmp4R-1627494063255)(http://note.youdao.com/yws/res/7220/WEBRESOURCE62dc2241276b1db2af53e23508e7293e)]

Executor:定义了线程的执行接口；
ExecutorService:继承Executor类，并且完善了整个线程池的生命周期；
ThreadPoolExecutor:

Callable

类似于rennable，但是有返回值

Future

存储将来将要产生的结果

        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

Future + Runnable；

        FutureTask<String> futureTask = new FutureTask<>(() -> {
            return "Hello Callable  Lambda!";
        });
        new Thread(futureTask).start(); //Future与Runnable的结合；
        System.out.println(futureTask.get());

CompletableFuture

管理多个Future的结果

public class CompletableFutureTest {
    public static void main(String[] args) {
        Long start =System.currentTimeMillis();
        CompletableFuture<Double> completableFuture = CompletableFuture.supplyAsync(new Supplier<Double>() {
            @Override
            public Double get() {
                return null;
            }
        });
        CompletableFuture TM = CompletableFuture.supplyAsync(()->getTM());
        CompletableFuture TB = CompletableFuture.supplyAsync(()->getTB());
        CompletableFuture JD = CompletableFuture.supplyAsync(()->getJD());
        CompletableFuture.allOf(TM,TB,JD).join();
        Long end =System.currentTimeMillis();
        System.out.println(end-start);

    }
    static Double getTM(){
        return 1.00;
    }
    static Double getTB(){
        return 2.00;
    }
    static Double getJD(){
        return 3.00;
    }
}

public class CompletableFuture_02 {
    public static void main(String[] args) {
        CompletableFuture.supplyAsync(()->getTM())
                .thenAccept(String::valueOf)
                .thenAccept(str -> "price : "+str)
                .thenAccept(System.out::println);
    }
    static Double getTM(){
        return 1.00;
    }
    static Double getTB(){
        return 2.00;
    }
    static Double getJD(){
        return 3.00;
    }
}