重新认识Thread

2025-01-07

java 锁是基于对象的对象锁

每个java对象，都wait和notify方法。

需要调用wait必须在synchronized块中，即有锁时才能调用。

调用wait之后会阻塞线程执行，直到被notify通知唤醒。

 wait(可能被假唤醒)

- - - - -

可以为线程增加全局异常监听setUncaughtExceptionHandler

- - - - -

private static final ThreadLocal<String> USER_CONTEXT = new ThreadLocal<>();  线程局部变量。

- - -

线程的几种状态：

1、NEW 新建待命状态

2、RUNNABLE 运行中

3、BLOCKED 被阻塞

4、WAITING 等待状态

5、TIMED_WAITING 限时等待

6、TERMINATED 执行完毕

 进入等待或者说限时等待有3种方式：

1、Object.wait

2、Thread.join

3、LockSupport.park

- - - - - -

Thread.onSpinWait()是Java 9引入的自旋等待优化API，用于在短时间自旋等待的场景中，向JVM和底层硬件传递“当前线程正在自旋等待”的信号，从而优化CPU资源的使用效率。

2026-01-19

        ExecutorService es = Executors.newFixedThreadPool(3);
        es.submit(()->{
            System.out.println("ok");
        });
        //es.shutdownNow();

Executors能创建几种线程池：

- - - - - - 

Future中能拿到结果的写法：

import java.util.concurrent.*;

public class FutureExample {
    public static void main(String[] args) throws Exception {
        // 1. 创建线程池
        ExecutorService executor = Executors.newFixedThreadPool(3);
        
        // 2. 提交Callable任务（有返回值）
        Future<String> future = executor.submit(() -> {
            Thread.sleep(1000); // 模拟耗时操作
            return "任务执行结果：" + Thread.currentThread().getName();
        });
        
        // 3. 阻塞获取结果（可设置超时时间）
        try {
            String result = future.get(2, TimeUnit.SECONDS); // 超时时间2秒
            System.out.println(result);
        } catch (TimeoutException e) {
            System.err.println("任务执行超时");
            future.cancel(true); // 取消任务
        } finally {
            executor.shutdown(); // 关闭线程池
        }
    }
}

线程链式调用：

import java.util.concurrent.*;

public class CompletableFutureChain {
    public static void main(String[] args) throws Exception {
        CompletableFuture.supplyAsync(() -> {
                // 第一步：异步获取数据
                System.out.println("线程1：获取数据");
                return "原始数据";
            }, Executors.newFixedThreadPool(2))
            .thenApplyAsync(data -> {
                // 第二步：异步处理数据
                System.out.println("线程2：处理数据");
                return data + " -> 处理后数据";
            })
            .thenAcceptAsync(result -> {
                // 第三步：异步消费结果
                System.out.println("线程3：消费结果：" + result);
            })
            .exceptionally(ex -> {
                // 全局异常处理
                System.err.println("异常处理：" + ex.getMessage());
                return null;
            })
            .join(); // 等待所有任务完成
    }
}

子任务同时进行，都执行完了，最后主线程做一个总结：

import java.util.concurrent.*;

public class ExecutorAwaitExample {
    public static void main(String[] args) throws InterruptedException {
        // 创建固定大小的线程池
        ExecutorService executor = Executors.newFixedThreadPool(2);
        
        // 提交多个任务
        for (int i = 0; i < 3; i++) {
            int taskId = i;
            executor.submit(() -> {
                try {
                    Thread.sleep(1000);
                    System.out.println("任务" + taskId + "执行完成");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        
        // 关闭线程池（不再接受新任务）
        executor.shutdown();
        
        // 主线程等待所有任务完成，超时时间设置为10秒
        System.out.println("主线程开始等待任务完成...");
        if (executor.awaitTermination(10, TimeUnit.SECONDS)) {
            System.out.println("所有任务执行完成，主线程继续执行");
        } else {
            // 超时后，取消剩余任务
            executor.shutdownNow();
            System.err.println("任务执行超时，强制关闭线程池");
        }
    }
}