线程相关个人笔记总结

什么是线程和进程

进程是一个程序的实例，线程是进程中的实体，一个进程有多个线程

线程的创建方式

1.继承 Thread 类重写 run() 

创建一个类继承自 Thread 类，并重写 run() 方法来定义线程执行的任务。

通过创建该类的实例并调用 start() 方法来启动线程。

class MyThread extends Thread {public void run() {// 线程执行的任务}
}
// 创建线程并启动
MyThread thread = new MyThread();
thread.start();

2.实现 Runnable 接口实现 run() 方法

创建一个实现 Runnable 接口的类，并实现其 run() 方法。

创建该类的实例，然后将其传递给一个新的 Thread 实例，并调用 start() 方法启动线程。

// 写法1：创建一个类实现 Runnable 接口实现 run() 方法
class MyRunnable implements Runnable {public void run() {// 线程执行的任务}
}
// 创建线程并启动
Thread thread = new Thread(new MyRunnable());
thread.start();// 写法2：使用匿名内部类在创建 Thread 或实现 Runnable 接口
Thread thread = new Thread(new Runnable() {public void run() {// 线程执行的任务}
});
thread.start();// 写法3： Lambda 表达式对匿名内部类方式进行简化
Thread thread = new Thread(() -> {// 线程执行的任务
});
thread.start();

3.使用 Callable 和 Future:

创建一个实现 Callable 接口的类，实现 call() 方法。

使用 ExecutorService 提交 Callable 任务，返回一个 Future 对象，通过 Future 获取线程执行的结果。

class MyCallable implements Callable<String> {public String call() {// 线程执行的任务return "Task completed!";}
}// 使用 ExecutorService 创建线程并启动
ExecutorService executor = Executors.newSingleThreadExecutor();
Future<String> future = executor.submit(new MyCallable());
try {String result = future.get();System.out.println(result);
} catch (InterruptedException | ExecutionException e) {e.printStackTrace();
}
executor.shutdown();

线程生命周期

 public enum State {// 创建:Thread 实例刚刚被创建，但尚未开始执行。NEW,// 就绪：调用 start() 方法进入就绪状态，等待获取CPU时间片，// 获取后进入运行状态，开始执行run() 方法中的任务。RUNNABLE,// 阻塞：线程被阻塞，暂时停止执行，// 一般在获取锁（synchronized，ReentrantLock）时被其他线程占用，或是等待I/O操作完成会进入阻塞BLOCKED,// 等待：线程进入等待状态，需要被手动唤醒。// 调用 Object.wait()、Thread.join()、LockSupport.park() 等方法会使线程进入等待状态。WAITING,// 超时等待：线程等待一定时间后自动唤醒。// 调用 Thread.sleep(timeout)、Object.wait(timeout)、Thread.join(timeout) 等方法会使线程进入超时等待状态。TIMED_WAITING,// 终止：线程的生命周期结束，如线程执行完任务，或者出现异常而结束TERMINATED;}

什么是ThreadLocal，可以用来做什么，怎么使用

ThreadLocal是线程级别的变量容器。每个线程都可以独立访问自己的 ThreadLocal 变量，线程之间互不影响。

一般可以用来传参，或是多线程下需要实现线程局部变量

// 创建 ThreadLocal 变量：（创建类型有多种）
private static ThreadLocal<MyObject> myObjectThreadLocal = ThreadLocal.withInitial(() -> new MyObject());
ThreadLocal.withInitial(() -> 0);
ThreadLocal.withInitial("wrxfxdd");（文本）
ThreadLocal.withInitial(() -> false);
ThreadLocal.withInitial(User：new);（对象）
ThreadLocal.withInitial(HashMap::new);（集合）// 设置线程局部变量的值
myObjectThreadLocal.set(new MyObject());
// 获取线程局部变量的值：
MyObject myObject = myObjectThreadLocal.get();
// 移除线程局部变量的值（
myObjectThreadLocal.remove();

什么是守护线程，用来做什么，怎么用

守护线程是在程序运行时在后台提供服务的线程。守护线程只有在普通线程全部结束后，jvm退出，才会终止

一般用来执行一些后台任务，如垃圾回收、内存管理等，例如，JVM 中的垃圾回收线程就是一个守护线程。但平时代码中很少用到，

Thread daemonThread = new Thread(() -> {while (true) {// 守护线程的逻辑}
});
daemonThread.setDaemon(true);
daemonThread.start();

线程类的常用方法

Thread.join（），（毫秒）

join是线程实例的方法，调用 join() 方法的这个实例线程会被阻塞，直到线程结束或者使用重载的join（时间）方法，如果超过该时间没有结束，当前线程就会继续执行。用于可以按照一定顺序执行线程任务

Thread.sleep(毫秒);

sleep（）是Thread类直接调用的方法，会让当前线程（一般是主线程）进入超时等待状态，超过该时间自动恢复就绪状态，可用于模拟耗时，或debug比如异步是否生效等

notify(); notifyAll():

notify() notifyAll() 方法都是object类的，notify()：如果有多个线程处于等待中，只会随机唤醒一个处于等待状态（通过wait()方法进入等待状态）的线程。notifyAll() ：唤醒所有处于等待状态的线程。

object.wait()，(毫秒);

wait() 方法是object类的，会让当前线程会释放对象的锁（即释放 synchronized 同步块的锁），并进入等待状态，直到被相同对象的object调用 notify() 或 notifyAll() 唤醒，主要用于线程间的同步和通信

public class WaitNotifyExample {private final Object lock = new Object();private boolean flag = false;public void waitForFlag() throws InterruptedException {synchronized (lock) {while (!flag) {System.out.println("Waiting...");lock.wait();}System.out.println("Flag is true. Continue with the task.");}}public void setFlag() {synchronized (lock) {flag = true;lock.notifyAll();}}public static void main(String[] args) {WaitNotifyExample example = new WaitNotifyExample();Thread waitingThread = new Thread(() -> {try {example.waitForFlag();} catch (InterruptedException e) {Thread.currentThread().interrupt();}});Thread notifyingThread = new Thread(() -> {// Simulate some worktry {Thread.sleep(2000);} catch (InterruptedException e) {Thread.currentThread().interrupt();}System.out.println("Setting the flag to true.");example.setFlag();});waitingThread.start();notifyingThread.start();}
}

注意事项

使用 wait() 方法，线程必须通过synchronized获取对象的锁，否则运行时会抛出 IllegalMonitorStateException 异常（因为wait()方法是Object类的方法，它要求在对象的监视器（即通过synchronized关键字获取锁而ReentrantLock是juc下的实现，不是Object子类）