Java多线程全体系教程 - 第二篇:Java多线程核心原理·线程安全与锁机制篇

Java多线程全体系教程 - 第二篇:Java多线程核心原理·线程安全与锁机制篇

适合人群:已经掌握多线程基础用法,需要解决线程安全问题、吃透锁机制、掌握线程通信的开发者

核心定位:多线程面试90%的考点都在本篇,也是开发中解决并发问题的核心,彻底搞懂「为什么会有线程安全问题」「怎么解决」「各种锁的区别与用法」。

一、什么是线程安全问题?为什么会出现?

1.1 线程安全问题的本质

当多个线程同时读写共享资源(共享变量、共享对象、静态资源、文件、数据库)时,由于CPU调度的随机性,多个线程交叉执行,导致共享数据被篡改、计算结果错误、数据不一致,这就是线程安全问题。

1.2 线程安全问题产生的3个必要条件

三个条件同时满足,才会出现线程安全问题,破坏任意一个,即可解决线程安全问题:

  1. 存在共享资源(多个线程同时访问同一个变量/对象);

  2. 多个线程对共享资源存在写操作(只有读操作,没有写操作,不会出现线程安全问题);

  3. 多个线程对共享资源的操作,不是原子操作。

1.3 线程不安全经典案例:卖票超卖

java 复制代码
/**
 * 线程不安全案例:多窗口卖票,出现超卖、重复卖票
 */
public class TicketSaleDemo {
    // 共享资源:总票数
    private static int ticketNum = 10;

    public static void main(String[] args) {
        // 3个线程,模拟3个售票窗口
        for (int i = 1; i <= 3; i++) {
            new Thread(() -> {
                // 循环卖票
                while (ticketNum > 0) {
                    try {
                        // 模拟售票耗时
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // 卖票操作
                    System.out.println(Thread.currentThread().getName() + "卖出第" + ticketNum + "张票,剩余:" + (--ticketNum));
                }
            }, "窗口" + i).start();
        }
    }
}

运行结果会出现:剩余票数为负数、重复卖出同一张票,这就是典型的线程安全问题。

二、解决线程安全问题的核心:锁机制

解决线程安全问题的核心思路:将对共享资源的并发操作,改为串行执行。

同一时间,只允许一个线程持有锁,执行操作共享资源的代码,其他线程必须等待,持有锁的线程执行完毕,释放锁之后,其他线程才能竞争锁执行。

Java中提供了两种最基础的锁实现:synchronized同步锁 、Lock显式锁。

2.1 synchronized同步锁(JVM内置锁,最常用)

synchronized是Java关键字,是JVM层面实现的内置锁,自动加锁、自动释放锁,使用简单,不会出现死锁(锁未释放)问题,是开发中解决线程安全问题的首选。

synchronized的3种使用场景
场景1:修饰实例方法,锁当前对象实例
java 复制代码
/**
 * 修饰实例方法,锁this当前对象
 */
public class SynchronizedMethodDemo {
    private int ticketNum = 10;

    // 修饰实例方法,锁当前对象
    public synchronized void saleTicket() {
        if (ticketNum > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出第" + ticketNum + "张票,剩余:" + (--ticketNum));
        }
    }

    public static void main(String[] args) {
        SynchronizedMethodDemo demo = new SynchronizedMethodDemo();
        // 多个线程,调用同一个对象的同步方法,共用同一把锁
        for (int i = 1; i <= 3; i++) {
            new Thread(demo::saleTicket, "窗口" + i).start();
        }
    }
}
场景2:修饰静态方法,锁当前类的Class对象
  • 静态方法属于类,不属于对象实例;

  • 修饰静态方法,锁是当前类的Class对象,全局唯一,所有线程访问该类的静态同步方法,共用同一把锁。

场景3:修饰同步代码块,灵活指定锁对象(推荐)

锁粒度更小,只锁需要同步的代码片段,不锁整个方法,性能更高,开发中优先使用。

java 复制代码
// 同步代码块,锁对象可以自定义
public void saleTicket() {
    // 任意对象都可以作为锁,锁对象必须是全局唯一的
    synchronized (this) {
        if (ticketNum > 0) {
            // 操作共享资源的逻辑
        }
    }
}

核心注意事项 :synchronized的锁效果,完全取决于锁对象是否唯一。多个线程必须使用同一把锁,才能实现同步;锁对象不同,锁无效,依然会出现线程安全问题。

synchronized的核心特性
  1. 可重入锁:同一个线程,可以多次获取同一把锁,不会出现自己锁死自己的问题;

  2. 非公平锁:线程竞争锁,完全随机,不遵循先来后到顺序;

  3. 自动加锁、自动释放锁:代码执行完毕、出现异常,JVM都会自动释放锁,不会出现锁泄漏;

  4. 阻塞等待:拿不到锁的线程,会进入BLOCKED阻塞状态,一直等待,直到拿到锁。

2.2 Lock显式锁(JDK实现的接口,灵活度更高)

Lock是java.util.concurrent.locks包下的接口,是JDK代码层面实现的锁,需要手动加锁、手动释放锁,灵活度更高,功能更强大,适合复杂的并发场景。

最常用的实现类:ReentrantLock(可重入锁)。

ReentrantLock标准用法
java 复制代码
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * ReentrantLock解决线程安全问题
 */
public class ReentrantLockDemo {
    private static int ticketNum = 10;
    // 创建锁对象,全局唯一
    private static final Lock lock = new ReentrantLock();

    public static void saleTicket() {
        // 手动加锁
        lock.lock();
        try {
            // 同步代码逻辑,操作共享资源
            if (ticketNum > 0) {
                System.out.println(Thread.currentThread().getName() + "卖出第" + ticketNum + "张票,剩余:" + (--ticketNum));
            }
        } finally {
            // 手动释放锁,必须放在finally中,保证无论是否异常,锁一定会释放
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        for (int i = 1; i <= 3; i++) {
            new Thread(ReentrantLockDemo::saleTicket, "窗口" + i).start();
        }
    }
}

核心注意事项 :Lock锁必须手动释放,且释放锁的代码必须放在finally代码块中。如果业务代码出现异常,锁没有释放,会导致锁泄漏,其他线程永远拿不到锁,引发死锁问题。

ReentrantLock相比synchronized的优势
  1. 支持公平锁/非公平锁可配置,synchronized只能是非公平锁;

  2. 支持超时获取锁,线程可以等待指定时间,拿不到锁就放弃,不会一直阻塞;

  3. 支持尝试获取锁,拿不到锁可以直接去做其他逻辑,不用阻塞等待;

  4. 支持精准唤醒指定线程,synchronized只能随机唤醒一个,或者唤醒所有线程。

2.3 synchronized与Lock锁的核心区别(必考)

对比维度 synchronized ReentrantLock
实现层面 JVM内置关键字,JVM层面实现 JDK接口,代码层面实现
锁释放 自动释放,执行完毕/异常自动释放 手动释放,必须调用unlock()
锁类型 非公平锁,不可配置 公平/非公平锁可自由配置
等待机制 无限阻塞等待,不可中断 支持超时等待、可中断、尝试获取锁
线程唤醒 只能随机唤醒/全部唤醒 支持Condition精准唤醒指定线程
使用成本 写法简单,不易出错 写法繁琐,容易忘记释放锁
开发选择建议
  • 普通的线程安全场景,优先使用synchronized,简单、安全、不易出错;

  • 复杂的高并发场景,需要公平锁、超时等待、精准唤醒等高级功能,使用ReentrantLock。

三、线程通信:wait()、notify()、notifyAll()

多个线程之间,除了同步执行,还需要相互通信、相互配合,完成业务逻辑(比如生产者消费者模型:生产线程生产完数据,通知消费线程消费;消费线程消费完,通知生产线程生产)。

Java提供了3个方法,实现线程之间的通信,这3个方法是Object类的方法,不是Thread类的方法,且必须在同步代码块/同步方法中使用。

3个方法的作用

  1. wait():让当前持有锁的线程,释放锁,进入WAITING等待状态,直到被其他线程唤醒;

  2. wait(long timeout):限时等待,超时自动唤醒;

  3. notify():随机唤醒一个正在当前锁上等待的线程;

  4. notifyAll():唤醒当前锁上所有正在等待的线程。

核心注意事项:

  1. wait()、notify()、notifyAll()必须在同步代码中使用,且必须是当前锁对象调用,否则会抛出IllegalMonitorStateException异常;

  2. wait()方法会释放持有的锁,而sleep()方法不会释放锁,这是二者最核心的区别;

  3. 开发中优先使用notifyAll(),避免notify()随机唤醒,导致线程饥饿,永远无法被唤醒。

经典案例:生产者消费者模型

java 复制代码
/**
 * 生产者消费者模型:线程通信经典案例
 */
public class ProducerConsumerDemo {
    // 共享资源:商品库存
    private static int stock = 0;
    // 锁对象
    private static final Object lock = new Object();

    // 生产者线程:生产商品
    static class Producer implements Runnable {
        @Override
        public void run() {
            while (true) {
                synchronized (lock) {
                    // 库存大于0,等待消费者消费
                    while (stock > 0) {
                        try {
                            // 释放锁,等待
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    // 生产商品
                    stock++;
                    System.out.println(Thread.currentThread().getName() + "生产商品,当前库存:" + stock);
                    // 唤醒消费者线程
                    lock.notifyAll();
                }
            }
        }
    }

    // 消费者线程:消费商品
    static class Consumer implements Runnable {
        @Override
        public void run() {
            while (true) {
                synchronized (lock) {
                    // 库存为0,等待生产者生产
                    while (stock == 0) {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    // 消费商品
                    stock--;
                    System.out.println(Thread.currentThread().getName() + "消费商品,当前库存:" + stock);
                    // 唤醒生产者线程
                    lock.notifyAll();
                }
            }
        }
    }

    public static void main(String[] args) {
        // 启动1个生产者,2个消费者
        new Thread(new Producer(), "生产者1").start();
        new Thread(new Consumer(), "消费者1").start();
        new Thread(new Consumer(), "消费者2").start();
    }
}

四、Java锁机制核心分类(面试高频)

Java锁按照不同的特性,分为很多类型,是面试必考点,这里用通俗的语言解释清楚,不绕弯子。

1. 公平锁 vs 非公平锁

  • 公平锁:线程按照申请锁的顺序,排队获取锁,先来先得,不会出现线程饥饿;缺点:性能较低,需要维护等待队列;

  • 非公平锁:线程竞争锁,随机获取,不排队,新来的线程可能直接抢到锁;优点:性能极高,吞吐量更大;缺点:可能出现线程饥饿,长时间拿不到锁。

默认情况:synchronized、ReentrantLock默认都是非公平锁。

2. 可重入锁 vs 不可重入锁

  • 可重入锁:同一个线程,多次获取同一把锁,不会阻塞,不会自己锁死自己;

  • 作用:避免同一个同步方法中,调用另一个同一个锁的同步方法,导致死锁。

synchronized、ReentrantLock都是可重入锁。

3. 共享锁 vs 排他锁(独占锁)

  • 排他锁(独占锁):同一时间,只允许一个线程持有锁,读、写都加排他锁,synchronized、ReentrantLock都是排他锁;

  • 共享锁:同一时间,多个线程可以同时持有锁,只能读,不能写;

  • 经典实现:ReadWriteLock读写锁,读锁是共享锁,写锁是排他锁。

4. 乐观锁 vs 悲观锁

  • 悲观锁:默认认为所有线程都会修改共享数据,所以每次访问都加锁,强制串行执行,synchronized、ReentrantLock都是悲观锁;

  • 乐观锁:默认认为线程不会修改共享数据,不加锁,更新数据时,判断数据是否被修改,没有修改就更新,被修改就放弃或重试;

  • 实现方式:CAS无锁机制,Java中的Atomic原子类,都是基于CAS乐观锁实现。

第二篇总结

本篇是Java多线程的核心难点,也是面试的重中之重,核心掌握4点:

  1. 线程安全问题的本质、产生条件,以及锁机制的解决思路;

  2. synchronized与ReentrantLock的用法、区别、使用场景;

  3. wait()、notify()线程通信机制,掌握生产者消费者模型;

  4. 各类锁的分类、特性、区别,应对面试考点。 Java多线程全体系教程 - 第二篇:Java多线程核心原理·线程安全与锁机制篇 适合人群:已经掌握多线程基础用法,需要解决线程安全问题、吃透锁机制

相关推荐
码事漫谈34 分钟前
以后人人都可以成为导演
后端
Resean022341 分钟前
Spring 源码分析(二)配置类的解析与扫描
java·后端·spring
一只爱撸猫的程序猿42 分钟前
五周、两个开源仓库、九次拦截之后:AI 时代程序员缺的到底是什么
人工智能·后端·开源
北城笑笑2 小时前
Vue 110 ,若依SSE流式接口限次空500排查与解决
前端·javascript·vue.js·后端·vue
ServBay3 小时前
Local harness 将退役,VS Code 本地开发要不要搬到云端?
后端·ai编程·visual studio code
ashiho3 小时前
【LeetCode hot 100】3. 无重复字符的最长子串 (三种解法)
java·数据结构·后端·算法·leetcode·滑动窗口
张一凡934 小时前
你的 AGENTS.md,真的管到模型写代码了吗?
前端·后端·agent
00后程序员4 小时前
iOS 实时活动怎么开发,Windows 上用 KXBuild 和 ActivityKit 写灵动岛
后端·ios
程序员cxuan4 小时前
推荐 10 个 WorkBuddy 中的邪修用法
人工智能·后端·程序员
Bacon5 小时前
给项目做一次"全身 CT":Agent Skills 生态里的代码体检全链路
前端·人工智能·后端