Java多线程

一、基本概念

1.什么是进程？

电脑中会有很多单独运行的程序，每个程序有一个独立的进程，而进程之间是相互独立存在的。
例如图中的微信、Chrome、idea等等。

image.png

2.什么是线程？

进程想要执行任务就需要依赖线程。
进程中的最小执行单位就是线程，并且一个进程中至少有一个线程。
补充：Java中有默认有几个线程？两个：main、gc

那什么又是多线程呢？

提到多线程这里要说两个概念，就是串行和并行，搞清楚这个，我们才能更好地理解多线程。

串行:

image.png

并行:

image.png

二、线程的创建

Java 提供了三种创建线程的方法：

//  通过继承 Thread 类本身
public class MyThread extends Thread {

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        //实例化自定义的线程
        Thread t = new MyThread("thread-aa");
        //启动线程
        t.start();
    }
}

Output：
thread-aa

Process finished with exit code 0

// 或使用匿名内部类
public class MyThread {
    public static void main(String[] args) {
        Thread thread = new Thread() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        };
        thread.start();
    }
}

// 通过实现 Runnable 接口
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
    public static void main(String[] args){
        Runnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
    }
}

// 通过 Callable 和 Future 创建线程
public class MyCallable implements Callable {
    @Override
    public String call() {
        System.out.println(Thread.currentThread().getName());
        return "有返回值。";
    }

    public static void main(String[] args){
        MyCallable myCallable = new MyCallable();
        FutureTask<String> futureTask = new FutureTask<>(myCallable);
        //传入线程执行目标，实例化线程对象
        Thread t = new Thread(futureTask);
        t.start();
        try {
            String r = futureTask.get();
            System.out.println(r);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

三、CompletableFuture

1. 概述

CompletableFuture是 Java 8 中引入的一个类

它实现了CompletionStage接口，提供了一组丰富的方法来处理异步操作和多个任务的结果。
它支持链式操作，可以方便地处理任务的依赖关系和结果转换。
相比于传统的Future接口，CompletableFuture更加灵活和强大。

CompletableFuture的使用具有以下优势和特点：

• 异步执行：CompletableFuture允许任务在后台线程中异步执行，不会阻塞主线程，提高了应用程序的响应性和性能。
• 链式操作：通过CompletableFuture提供的方法，可以方便地对任务进行链式操作，构建复杂的任务依赖关系，实现高效的任务调度和执行。
• 异常处理：CompletableFuture提供了丰富的异常处理方法，可以处理任务执行过程中可能发生的异常，并实现灵活的错误处理和回退机制。
• 多任务组合：CompletableFuture支持多个任务的并发执行和结果组合。可以轻松地实现多任务并发处理的场景，提高应用程序的效率和并发性。

2. 具体使用网上有很多文档

个人觉得这种方式最优雅，也是我最常使用的。

public class TestCompletableFuture {
    public static void main(String[] args) {
        CompletableFuture.runAsync(() -> System.out.println(Thread.currentThread().getName() + " 1")).join();
    }
}

3.实战案例

业务背景： 在电商项目的售后业务中，当客服接收到用户的售后申请时，需要进行一系列操作，包括查询订单信息、查询 ERP 中的商品信息、查询用户信息，以及创建售后工单。

public CompletableFuture<Void> processAfterSalesRequest(String orderId, String customerId) {
    CompletableFuture<Order> orderFuture = CompletableFuture.supplyAsync(() -> getOrderInfo(orderId));
    CompletableFuture<Inventory> inventoryFuture = CompletableFuture.supplyAsync(() -> getInventoryInfo(orderId));
    CompletableFuture<User> userFuture = CompletableFuture.supplyAsync(() -> getUserInfo(customerId));

    return CompletableFuture.allOf(orderFuture, inventoryFuture, userFuture)
        .thenApplyAsync(ignored -> {
            Order order = orderFuture.join();
            Inventory inventory = inventoryFuture.join();
            User user = userFuture.join();

            // 创建售后工单
            createAfterSalesTicket(order, inventory, user);

            return null;
        });
}

private Order getOrderInfo(String orderId) {
    // 查询订单信息的逻辑
    // ...
    return order;
}

private Inventory getInventoryInfo(String orderId) {
    // 查询ERP中商品信息的逻辑
    // ...
    return inventory;
}

private User getUserInfo(String customerId) {
    // 查询用户信息的逻辑
    // ...
    return user;
}

private void createAfterSalesTicket(Order order, Inventory inventory, User user) {
    // 创建售后工单的逻辑
    // ...
}

四、线程池

经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。
可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。

好处：

1. 提高响应速度（减少了创建新线程的时间）
2. 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
3. 便于线程管理
   • corePoolSize：核心池的大小
   • maximumPoolSize：最大线程数
   • keepAliveTime：线程没有任务时最多保持多长时间后会终止

JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors

ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor

• void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行RunnableFuture
• submit(Callable task)：执行任务，有返回值，一般又来执行
• Callablevoid shutdown() ：关闭连接池

Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

public class MyThreadPool implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }

    public static void main(String[] args) {
        // 线程池
        ExecutorService pool = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor executor = (ThreadPoolExecutor) pool;
        /*
         * 可以做一些操作:
         * corePoolSize：核心池的大小
         * maximumPoolSize：最大线程数
         * keepAliveTime：线程没任务时最多保持多长时间后会终止
         */
        executor.setCorePoolSize(5);
        // 开启线程
        executor.execute(new MyThreadPool());
        executor.execute(new MyThreadPool());
        executor.execute(new MyThreadPool());
        executor.execute(new MyThreadPool());

    }
}