006_Java 线程、线程池

大能嘚吧嘚

已于 2025-08-10 17:23:17 修改

阅读量247

点赞数 1

CC 4.0 BY-SA版权

分类专栏： Java 文章标签： java 开发语言后端

于 2021-10-31 16:39:33 首次发布

本文链接：https://blog.csdn.net/qq_30818545/article/details/121064921

Java 专栏收录该内容

12 篇文章

订阅专栏

前言

线程必须依附于进程存在，无法单独运行（进程是操作系统运行应用程序的映射）
在多线程设计中，线程间的切换和调度比进程更高效，因此建议采用多线程实现并发
CPU采用时间片轮转机制分配资源：为每个线程动态分配时间片，线程在时间片内独占CPU执行任务。时间片耗尽后线程转为就绪状态，等待下次分配。由于CPU能快速切换线程，用户会感知到多个线程同时执行（即并发效果）

线程的分类

用户线程：用户自定义的线程
守护线程：持续为用户线程提供服务，直到所有用户线程执行完毕。（例如JVM的垃圾回收机制本质上就是一个守护线程）

线程的创建

Runnable 接口

class DemoRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println(MessageFormat.format("线程名称：{0} 正在执行", Thread.currentThread().getName()));
    }
}

public class Demo {
    public static void main(String[] args) {
        Thread thread = new Thread(new DemoRunnable(), "自定义线程A");
        thread.start();
    }
}

Callable 接口（有返回值）

class DemoCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        String res = "运行成功";
        System.out.println(MessageFormat.format("线程名称：{0} 正在执行, 运行结果位：{1}", Thread.currentThread().getName(), res));
        return res;
    }
}

public class Demo {
    public static void main(String[] args) {
        FutureTask<String> futureTask = new FutureTask<String>(new DemoCallable());
        Thread thread = new Thread(futureTask, "自定义线程A");
        thread.start();
        // TODO 每秒轮询一次，检查当前线程是否执行完毕
        while (!futureTask.isDone()) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        try {
            // TODO 获取当前线程中的返回值（get会阻塞当前线程）
            System.out.println("返回值：" + futureTask.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

Java8引入CompletableFuture类实现了CompletionStage和Future接口，提供了函数式异步编程的能力，通过操作系统回调函数的方式处理异步结果，相比于Future它不会造成主线程的阻塞现象

线程的生命周期

调用start方法会使线程进入就绪状态（等待CPU分配时间片）。
当获取到时间片后，系统会自动调用run或call方法执行任务（直接调用这些方法不会生效）。
任务执行完成后，线程会被自动销毁。

yield
释放占用的资源，重新进入就绪状态
wait
释放占用的资源，在指定时间后重新进入就绪状态（如果没有指定时间则需要通过其它线程来唤醒）
sleep
不释放占用的资源，阻塞其它线程，直到休眠结束
join
在执行过程中，遇到其它线程join时，会等待该线程执行成功后才会继续执行

线程池（避免重复创建、销毁线程所带来的额外开销）

阿里巴巴java开发手册中明确指出线程资源必须通过线程池提供，不允许在应用中自行显示的创建线程
线程池不允许使用Executors创建（不够灵活，不可控），而要通过ThreadPoolExecutor（创建符合自己业务场景的线程池）

ThreadPoolExecutor【Exectutor接口-ExecutorService接口-ThreadPoolExecutor类】

核心参数（以有界队列为例）

corePoolSize：初始线程数量
workQueue：当线程并发数量超过初始线程数量时，待处理的线程存入阻塞队列进行管理
maximumPoolSize：阻塞队列中的线程数量达到最大时，可继续创建线程的最大数量	
handler：拒绝策略（当最大线程数量都达到最大时，处理新提交任务的策略）
keepAliveTime：空闲线程的存活时间（unit：时间单位）

public static void main(String[] args) {
    ExecutorService executorService = new ThreadPoolExecutor(
            2,10,30, TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(10),
            new ThreadPoolExecutor.CallerRunsPolicy());
    for (int i = 0; i < 2; i++) {
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(MessageFormat.format("线程名称：{0}", Thread.currentThread().getName()));
            }
        });
    }
    // 关闭线程
    executorService.shutdown();
}

workQueue任务队列

SynchronousQueue【直接提交队列】
提交的任务会立即执行：
任务数量 < maximumPoolSize，则尝试创建新的线程
任务数量 > maximumPoolSize，则会触发拒绝策略
注意：需要对程序的并发量有准确评估，才能设置合适的maximumPoolSize，否则很容易会执行拒绝策略
LinkedBlockingQueue【无界队列】
线程池初始化时会默认创建 corePoolSize 个线程：
任务数量 = corePoolSize 后就不会再增加，后续任务直接进入队列(自动扩容，无限增长)等待
注意：队列中的任务要及时处理，不然会导致一直增长，直到最后资源耗尽
PriorityBlockingQueue【优先队列】
特殊的无界队列，无界任务队列一般是按照先进先出的规则处理任务，而优先任务队列则可以自定义任务执行的优先级
ArrayBlockingQueue【有界队列】
线程池初始化时会默认创建 corePoolSize 个线程：
任务数量 > corePoolSize，则会将新的任务加入到队列，队列已满则继续创建线程直至 maximumPoolSize
任务数量 > maximumPoolSize，则会触发拒绝策略