Java多线程，ThreadLocal，锁，Synchronized的理解

目录

多线程

1.进程与线程

2.并发与并行

3.线程的使用创建

4.线程的生命周期

5.常用方法

ThreadLocal 

1.常用方法

2.使用步骤（以苍穹外卖为列）

3.ThreadLocal与Synchronized的区别

Synchronized

1.使用方式

锁

1.死锁

（1）产生死锁的 4 个必要条件

（2）代码示例

2.乐观锁与悲观锁

多线程

1.进程与线程

想象一下，开了一家餐厅（服务器）

进程（Process）=整个餐厅，如果餐厅倒闭了=进程结束了，里面的东西都没了

线程（Thread）=厨师。单线程就是一个厨师干店里面活，多线程就是多个厨师干店里面的活

2.并发与并行

并发：同一时间内，A先发生，B后发生（多个任务在同一个内核上）

并行：同意时间内，AB同时发生（多个任务在多个内核上）

3.线程的使用创建

（1）继承 Thread 类 （不推荐，因为受限于 Java 的单继承特性（继承了 Thread 就不能继承其他业务类了）

// 1. 定义一个类继承 Thread
class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("子线程运行中... 当前线程: " + Thread.currentThread().getName());
        // 写你的业务逻辑
    }
}
// 2. 创建对象并启动
public class Demo1 {
    public static void main(String[] args) {
        MyThread t = new MyThread();
        t.start(); //  必须调用 start()，不能直接调用 run()
        // 如果调用 t.run()，那就只是普通方法调用，还是在主线程执行！
        
        System.out.println("主线程继续运行...");
    }
}

（2）实现 Runnable 接口 (推荐，将“任务逻辑”和“线程控制”分离，避免了单继承的限制)

// 1. 定义任务类实现 Runnable
class MyTask implements Runnable {
    @Override
    public void run() {
        System.out.println("任务执行中... 当前线程: " + Thread.currentThread().getName());
    }
}

public class Demo2 {
    public static void main(String[] args) {
        MyTask task = new MyTask();
        // 2. 把任务交给 Thread 对象
        Thread t = new Thread(task); 
        t.start();
        
        // Lambda 简化写法 (Java 8+)
        new Thread(() -> System.out.println("Lambda 方式运行")).start();
    }
}

（3）实现 Callable 接口 + FutureTask (需要返回值时用），如果你需要线程执行完后返回结果，或者需要抛出检查型异常，用这个

import java.util.concurrent.*;

public class Demo3 {
    public static void main(String[] args) throws Exception {
        // 1. 定义任务，可以有返回值 (Integer)
        Callable<Integer> task = () -> {
            System.out.println("计算中...");
            Thread.sleep(2000); // 模拟耗时
            return 100 + 200; // 返回结果
        };

        // 2. 包装成 FutureTask
        FutureTask<Integer> futureTask = new FutureTask<>(task);
        Thread t = new Thread(futureTask);
        t.start();

        System.out.println("主线程在做别的事...");

        // 3. 获取结果 (会阻塞，直到子线程算完)
        // 如果子线程没跑完，这里会一直等；跑完了直接拿结果
        Integer result = futureTask.get(); 
        System.out.println("子线程返回结果: " + result);
    }
}

（4）使用线程池 

4.线程的生命周期

5.常用方法

ThreadLocal 

定义：让每个线程拥有自己独立的变量副本，互不干扰，用于线程隔离

1.常用方法

2.使用步骤（以苍穹外卖为列）

（1）定义 ThreadLocal 变量

（2）设置值 (Set)。在请求进入时（如拦截器、Filter、AOP）或任务开始时，将数据存入。

（3）获取值 (Get)。在业务逻辑的任何地方（Service, Controller, Mapper），只要是在同一个线程内，都可以直接取，不需要层层传递参数。

（4）清理值 (Remove) 这是最关键的一步！ 必须在请求结束或任务完成后清理，否则会导致内存泄漏。通常在 finally 块中执行。

package sky.context;

public class BaseContext {
    /**
     * 基于ThreadLocal封装工具类，用于保存和获取当前登录用户ID
     */
    //定义 ThreadLocal 变量
    public static ThreadLocal<Long> threadLocal = new ThreadLocal<>();
    //设置当前线程的ID
    public static void setCurrentId(Long id) {
        threadLocal.set(id);
    }
    //获取当前线程的ID
    public static Long getCurrentId() {
        return threadLocal.get();
    }//移除当前线程的ID
    public static void removeCurrentId() {
        threadLocal.remove();
    }

}

3.ThreadLocal与Synchronized的区别

Synchronized

1.使用方式

（1）修饰实例方法（锁的是 this）

public synchronized void doSomething() {
    // 临界区代码
}

（2）修饰静态方法（锁的是 Class 对象）

public static synchronized void doStaticSomething() {
    // 临界区代码
}

（3） 修饰代码块（锁的是指定的对象）最推荐

public void doWork() {
    // 这里的 "lockObj" 可以是 this, 也可以是 new Object(), 或者一个常量
    synchronized (this) { 
        // 临界区代码
    }
}

锁

在多线程编程中，锁（Lock） 是解决线程安全问题的核心机制。

它的本质是：同一时刻，只允许一个线程访问共享资源。如果没有锁，多个线程同时修改同一个变量（如 count++），就会导致数据错乱（线程不安全）。

1.死锁

死锁 (Deadlock) 是多线程编程中最棘手的问题之一。简单来说，就是两个或多个线程互相等待对方释放资源，结果谁也无法继续执行，大家永远卡在那里。

（1）产生死锁的 4 个必要条件

（2）代码示例

public class DeadLockDemo {
    // 定义两个锁对象
    private static final Object lockA = new Object();
    private static final Object lockB = new Object();

    public static void main(String[] args) {
        // 线程 1：先拿 A，再拿 B
        Thread t1 = new Thread(() -> {
            synchronized (lockA) {
                System.out.println("线程 1 获得了锁 A，准备获取锁 B...");
                try { Thread.sleep(100); } catch (InterruptedException e) {} // 模拟耗时，增加死锁概率
                
                synchronized (lockB) {
                    System.out.println("线程 1 获得了锁 B");
                }
            }
        });

        // 线程 2：先拿 B，再拿 A (顺序反了！)
        Thread t2 = new Thread(() -> {
            synchronized (lockB) {
                System.out.println("线程 2 获得了锁 B，准备获取锁 A...");
                try { Thread.sleep(100); } catch (InterruptedException e) {} 
                
                synchronized (lockA) {
                    System.out.println("线程 2 获得了锁 A");
                }
            }
        });

        t1.start();
        t2.start();
        
        // 程序将在这里卡住，没有任何输出后续...
    }
}

2.乐观锁与悲观锁

核心区别就一句话：你是“先锁门再办事”，还是“先办事再检查”？