03-多线程分类

死锁的避免

持有并等待。尝试获取锁，超时则释放已有锁并重试。
保证所有线程获取锁的顺序完全一致

shutdown()和shutdownNow()

调用线程池的shutdown()或shutdownNow()方法，线程当前状态如何处理

线程当前状态	shutdown()	shutdownNow()
正在执行任务	继续执行，完成后退出	中断线程，但任务可能继续执行，取决于是否响应中断，不是"完成后退出"，而是任务执行完后检测到 `STOP` 状态退出，如果任务不响应中断，会一直执行到完成（可能无限循环）
等待获取任务	中断空闲线程，线程在 workQueue.take() 处被中断，抛出InterruptedException异常，线程池自己捕捉到这个异常，继续自旋判断如果队列为空，rerurn null后，线程自然结束。	中断所有线程，线程在 workQueue.take() 处被中断，抛出InterruptedException异常，线程池自己捕捉到这个异常，继续自旋判断发现是STOP，不管任务队列是否为空直接rerurn null后，线程自然结束。
刚获取任务	正常执行该任务	中断线程，任务可能执行也可能不执行，任务可能继续执行，取决于是否响应中断，不是"完成后退出"，而是任务执行完后检测到 `STOP` 状态退出，如果任务不响应中断，会一直执行到完成（可能无限循环）
新提交任务	拒绝（抛出异常）	拒绝（抛出异常）
线程池状态	SHUTDOWN	STOP

Ms.Zyh2026/9/27大约 6 分钟

01-线程基础

一，线程的创建

1.1 继承Thread类

public class ThreadCreateTest extends Thread {
    @Override
    public void run() {
        // 逻辑
    }
   
}

Ms.Zyh2026/9/27大约 9 分钟

02-线程池ThreadPoolExecutor

一，ThreadPoolExecutor

全参构造函数参数介绍，在Java中创建线程池常用的类是ThreadPoolExecutor，该类的全参构造函数如下：

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
}

Ms.Zyh2026/9/27大约 20 分钟

03-CAS和Atomic

一，CAS

1.1 介绍

while(true){
    // 1，预期值X
    // 2，要修改的新值Y
    if(CompareAndSet(X,Y)){
        break;
    }
}

Ms.Zyh2026/9/27大约 11 分钟

05-ReentrantReadWriteLock原理

一，ReentrantReadWriteLock原理

读写锁用的是同一个 Sycn 同步器，因此等待队列、state 等也是同一个，写锁状态占了 state 的低 16 位，而读锁使用的是 state 的高 16 位；（state是int类型，占4个字节，4*8 = 32位）。

1.1 WriteLock的lock()

WriteLock的lock()方法：

public void lock() {
    sync.acquire(1);
}

Ms.Zyh2026/9/27大约 18 分钟

06-Semaphore原理

一，Semaphore原理

信号量，用来限制能同时访问共享资源的线程上限，就好像ReentrantLock只允许一个线程进去，而Semaphore最多只允许n个线程进去，常用于资源访问，服务限流(Hystrix里限流就有基于信号量方式)

1.1 简单使用

public class SemaphoreRunner {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(2);
        for (int i=0;i<5;i++){
            new Task(semaphore,"zyh"+i).start();
        }
    }
    static class Task extends Thread{
        Semaphore semaphore;
        public Task(Semaphore semaphore,String tname){
            this.semaphore = semaphore;
            this.setName(tname);
        }
        public void run() {
            try {
                semaphore.acquire();
                System.out.println(Thread.currentThread().getName()+":aquire():"+System.currentTimeMillis());
                Thread.sleep(1000);
                semaphore.release();
                System.out.println(Thread.currentThread().getName()+":release():"+System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}

Ms.Zyh2026/9/27大约 4 分钟

07-CountDownLatch和CyclicBarrier

一，CountDownLatch

作用：CountDownLatch类能够使一个线程等待其他线程完成各自的工作后再执行。

使用场景：Zookeeper分布式锁，Jmeter模拟高并发等。

工作原理：CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。每当一个线程完成了自己的任务后，通过调用``countDown();`方法使计数器的值就会减1，当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。

public class CountDownLatchTest {
	private static CountDownLatch countDownLatsh = new CountDownLatch(5);
    private static class Player implements Runnable{
        private Integer index;
        public Player(Integer index){
            this.index = index;
        }
        @Override
        public void run() {
            System.out.println("玩家"+index+"准备完成");
            countDownLatsh.countDown();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        for(int i = 0; i < 5; i++){
            new Thread(new Player(i)).start();
        }
        countDownLatsh.await();
        System.out.println("玩家准备完毕，开始游戏");
    }
}

Ms.Zyh2026/9/27大约 3 分钟

08-JMM模型

一，JMM模型

1.1 介绍

Java内存模型(Java Memory Model简称JMM)是一种抽象的概念，并不真实存在，它描述的是一组规则或规范，通过这组规范定义了程序中各个变量（包括实例字段，静态字段和构成数组对象的元素）的访问方式。每个JVM 的实现都要遵守JMM规范，JMM规范的保障了并发程序运行在不同的虚拟机上时，得到的程序结果是安全可靠的。如果没有JMM内存模型来规范，就可能会出现，经过不同 JVM 翻译之后，运行的结果不相同也不正确的情况。

1.2 主内存和工作内存

java运行时内存模型JVM运行程序的实体是线程，在每个线程创建时，JVM都会为其创建一个工作内存(有些地方称为栈空间)，用于存储线程私有的数据。Java 内存模型JMM规定所有变量都存储在主内存，主内存是共享内存区域，所有线程都可以访问，但线程对变量的操作(读取赋值等)必须在工作内存中进行。工作内存是线程私有，所以不同的线程间无法访问对方的工作内存，线程间的通信(传值)必须通过主内存来完成。

Ms.Zyh2026/9/27大约 16 分钟

04-ReentrantLock原理解析

一，ReentrantLock原理解析

ReentrantLock的基本实现可以概括为：先通过CAS尝试获取锁。如果此时已经有线程占据了锁，那就加入AQS队列并且被挂起。当锁被释放之后，排在CLH队列队首的线程会被唤醒，然后CAS再次尝试获取锁。在这个时候，如果：

非公平锁：如果同时还有另一个线程进来尝试获取，那么有可能会让这个线程抢先获取；
公平锁：如果同时还有另一个线程进来尝试获取，当它发现自己不是在队首的话，就会排到队尾，由队首的线程获取到锁；

1.1 AQS介绍

AbstractQueuedSynchronizer简称AQS，是一个用于构建锁和同步容器的框架。事实上于java.concurrent.util包内许多类都是基于AQS构建，例如ReentrantLock，Semaphore，CountDownLatch，ReentrantReadWriteLock，FutureTask等。AQS解决了在实现同步容器时设计的大量细节问题。

Ms.Zyh2026/9/27大约 26 分钟

09-volatile的原理

一，volatile的原理

volatile是Java虚拟机提供的轻量级的同步机制。volatile关键字有如下两个作用

保证被volatile修饰的共享变量对所有线程总数可见的，也就是当一个线程修改了一个被volatile修饰共享变量的值，新值总是可以被其他线程立即得知。
禁止指令重排序优化
可见性：是通过汇编的lock指令实现的。涉及数据总线和缓存一致性协议，详情可以看[[08-JMM模型]]。
有序性: 是通过内存屏障保证的防止指令重排序，重排序遵循as-if-serial和happens-before原则。as-if-serial原则是不管你怎么排序，单线程执行的结果是不能改变的。

Ms.Zyh2026/9/27大约 11 分钟