Java 线程、线程池

• 前言
  1、线程不可单独存在，必须存在于进程中（进程是操作系统中打开一个应用程序的映射）
  2、推荐使用多线程来实现程序的并发设计，线程间的切换与调度对资源的消耗要远远小于进程
  3、CPU的资源分配采用了时间片轮转策略【CPU会为每一个线程动态的分配一个时间片，每个线程在各自的时间片内占用CPU执行相关操作，当时间片用完后便进入就绪状态等待CPU再次为其分配时间片】，因为CPU执行线程间的切换很快，所以用户感觉多个线程是在同时执行（即多线程并发）

线程的分类

• 用户线程：用户自定义的线程
• 守护线程：服务于用户线程，直到相关用户线程都执行完毕后jvm进程退出，此时守护线程才会跟着一起退出（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();
        }
    }
}

线程的生命周期

调用start()方法后会进入就绪状态，等待CPU为其分配时间片，获取时间片后才会调用run()方法、call()方法进行相关操作(注意直接调用是不生效的)，执行结束后线程将会被销毁

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

线程池（有效避免重复创建、销毁线程所带来的不必要开销）

Exectutor 接口 – ExecutorService 接口 – ThreadPoolExecutor 类

• 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();
}

线程名称：pool-1-thread-1
线程名称：pool-1-thread-2

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++) {
        Future<Integer> future = executorService.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                return 1;
            }
        });
        // TODO 每秒轮询当前线程的状态
        while (!future.isDone()) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // TODO 当前线程执行成功后从Future中取出返回值
        try {
            System.out.println(future.get());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    // 关闭线程
    executorService.shutdown();
}

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