并发编程基础Ⅰ

多线程使用场景

1. 通过并行计算提高程序执行性能
2. 需要等待网络、I/O 响应导致耗费大量的执行时间，可以采用异步线程的方式来减少阻塞

线程的实现方式

在 Java 中，有多种方式来实现多线程。继承 Thread 类、实现 Runnable 接口、使用 ExecutorService、Callable、Future 实现带返回结果的多线程。如果不需要获取线程的返回结果，推荐使用实现 Runnable 接口的方式。

1.继承 Thread 类创建线程

public class ThreadDemo extends Thread {

    @Override
    public void run() {
        System.out.println("继承 Thread 类创建线程");
    }

    public static void main(String[] args) {
        new ThreadDemo().start();
    }
}

2.实现 Runnable 接口创建线程

public class RunnableDemo implements Runnable {

    @Override
    public void run() {
        System.out.println("实现 Runnable 接口创建线程");
    }

    public static void main(String[] args) {
        new Thread(new RunnableDemo()).start();
    }
}

3.实现 Callable 接口通过 FutureTask 包装器来创建 Thread

public class CallableDemo1 implements Callable<String> {

    @Override
    public String call() throws Exception {
        return "实现 Callable 接口通过 FutureTask 包装器来创建 Thread";
    }

    public static void main(String[] args) {
        // 使用单个线程处理Callable
        CallableDemo1 callableDemo = new CallableDemo1();
        FutureTask<String> futureTask = new FutureTask<>(callableDemo);
        new Thread(futureTask).start();
        try {
            System.out.println(futureTask.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

public class CallableDemo2 implements Callable<String> {

    @Override
    public String call() throws Exception {
        return "实现 Callable 接口通过 FutureTask 包装器来创建 Thread";
    }

    public static void main(String[] args) {
        // 使用线程池处理Callable
        CallableDemo2 callableDemo = new CallableDemo2();
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        Future<String> future = executorService.submit(callableDemo);
        try {
            System.out.println(future.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        executorService.shutdown();
    }
}

public class CallableDemo3 implements Callable<String> {

    @Override
    public String call() throws Exception {
        return "实现 Callable 接口通过 FutureTask 包装器来创建 Thread";
    }

    public static void main(String[] args) {
        // 使用ExecutorCompletionService接收线程池执行的结果
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        CallableDemo3 callableDemo3 = new CallableDemo3();
        CompletionService<String> completionService = new ExecutorCompletionService<>(executorService);
        completionService.submit(callableDemo3);

        Future<String> future;
        try {
            future = completionService.take();
            System.out.println(future.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

        executorService.shutdown();
    }
}