并发问题系统学习（更新中）

进程、线程

进程：进程是代码在数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位。可以理解为一个java应用。
线程：线程是进程的一个执行路径，一个进程中至少有一个线程，进程中的多个线程共享进程的资源。

一个进程中有多个线程，多个线程共用进程的堆和方法区资源，但是每个线程有自己的程序计数器和栈。但会导致内存泄漏、上下⽂切换、死锁。

多线程和锁的关系

只有拿到锁的线程才能访问共享资源，多线程之间的通信和协作，通常使用锁和等待/通知机制来实现。

线程死锁

线程 A 持有资源 2 ，线程 B 持有资源 1 ，他们同时都想申请对⽅的资源，所以这两个线程就会互相等待⽽进⼊死锁状态。当程序出现了死锁现象，我们可以使用jdk自带的工具：jps和 jstack

并发、并行

简单说，轮流做是并发，一起做是并行。

线程创建方式

继承Thread类，重写run()方法，调用start()方法启动线程

一个例子

这段代码输出结果可能是ab或者ba。

实现 Runnable 接口，重写run()方法

上面两种都是没有返回值的。

实现Callable接口，重写call()方法，这种方式可以通过FutureTask获取任务执行的返回值

JVM执行start方法，会先创建一条线程，由创建出来的新线程去执行thread的run方法，这才起到多线程的效果。直接执行run方法就相当于执行一个普通的方法。直接执行thread中的run方法也是相当于顺序执行run方法。

线程等待、休眠与通知

等待

休眠

等待和休眠区别

通知

实例

执行顺序

停止线程

使用退出标志，使线程正常退出。
volatile boolean flag = false ;t1.flag = true ;
stop强行终止t1.stop();

interrupt

Thread t2 = new Thread(()->{
while(true) {
Thread current = Thread.currentThread();
boolean interrupted = current.isInterrupted();
if(interrupted) {
System.out.println("打断状态："+interrupted);
break;
}
}
}, "t2");
t2.start();
Thread.sleep(500);

线程上下文切换

使用多线程的目的是为了充分利用CPU，但是我们知道，并发其实是一个CPU来应付多个线程。

为了让用户感觉多个线程是在同时执行的， CPU 资源的分配采用了时间片轮转也就是给每个线程分配一个时间片，线程在时间片内占用 CPU 执行任务。当线程使用完时间片后，就会处于就绪状态并让出 CPU 让其他线程占用，这就是上下文切换。

守护线程

Java中的线程分为两类，分别为 daemon 线程（守护线程）和 user 线程（用户线程）。

在JVM 启动时会调用 main 函数，main函数所在的线程就是一个用户线程。其实在 JVM 内部同时还启动了很多守护线程，比如垃圾回收线程。

那么守护线程和用户线程有什么区别呢？区别之一是当最后一个非守护线程束时， JVM会正常退出，而不管当前是否存在守护线程，也就是说守护线程是否结束并不影响 JVM退出。换而言之，只要有一个用户线程还没结束，正常情况下JVM就不会退出。

线程间有哪些通信方式（操作系统）

`volatile` 的作用主要

保证可见性： 当一个变量被声明为 volatile 后，对该变量的写操作会立即被其他线程所看到，保证了多个线程之间对该变量的可见性。换句话说，一个线程对 volatile 变量的修改对其他线程是可见的，不会出现线程间的数据不一致问题。例：

static volatile boolean stop = false;

禁止指令重排序： volatile 变量的读写操作会插入内存屏障，防止编译器和处理器对其进行指令重排序优化，保证了代码执行的顺序性。这样可以确保对 volatile 变量的写操作先于后续的读操作，避免出现因指令重排序导致的意外结果。

写变量让volatile修饰的变量的在代码最后位置
读变量让volatile修饰的变量的在代码最开始位置

总的来说，volatile 主要用于在多线程环境中确保变量的可见性和一致性，它适用于一种场景：变量被多个线程共享，并且这些线程可能会同时读写这个变量。通过使用 volatile 关键字，可以有效地避免由于线程间数据不一致导致的并发问题。

并发锁

synchronized【对象锁】关键字的使用

synchronized 关键字解决的是多个线程之间访问资源的同步性， synchronized 关键字可以保证

被它修饰的⽅法或者代码块在任意时刻只能有⼀个线程执⾏。Synchronized【对象锁】采用互斥的方式让同一时刻至多只有一个线程能持有【对象锁】，其它线程再想获取这个【对象锁】时就会阻塞住。

1. 修饰代码块 synchronized (this) 和 synchronized (lock)

指定加锁对象，对给定对象 / 类加锁。 synchronized(this/object) 表示进⼊同步代码库前要获得给定对象的锁 。 synchronized(类 .class) 表示进⼊同步代码前要获得当前 class 的锁。

synchronized (this)：这种方式是在非静态方法中使用的，它将当前对象（即调用该方法的对象）作为同步锁。只有在同一对象实例上获取锁的线程才能进入同步代码块，其他线程需要等待当前对象锁释放后才能继续执行。因此，同一对象的不同方法之间也是同步的。
synchronized (lock)：这种方式是在静态方法或者普通代码块中使用的，它将指定的对象作为同步锁。通常情况下，会使用一个静态对象作为锁。多个线程在获取到相同的锁对象时才能进入同步代码块，其他线程需要等待锁释放后才能执行。因此，不同对象实例上的同步代码块之间是独立的，不会相互影响。

2. 修饰实例⽅法 : 作⽤于当前对象实例加锁，进⼊同步代码前要获得 当前对象实例的锁

3. 修饰静态⽅法 : 也就是给当前类加锁，会作⽤于类的所有对象实例，进⼊同步代码前要获得当

前 class 的锁。因为静态成员不属于任何⼀个实例对象，是类成员（ static 表明这是该类的⼀个

静态资源，不管 new 了多少个对象，只有⼀份）。所以，如果⼀个线程 A 调⽤⼀个实例对象的

⾮静态 synchronized ⽅法，⽽线程 B 需要调⽤这个实例对象所属类的静态 synchronized ⽅法，

是允许的，不会发⽣互斥现象， 因为访问静态 synchronized ⽅法占⽤的锁是当前类的锁，⽽访

问⾮静态 synchronized ⽅法占⽤的锁是当前实例对象锁 。

总结：

synchronized 关键字加到 static 静态⽅法和 synchronized(class) 代码块上都是是给 Class

类上锁。

synchronized 关键字加到实例⽅法上是给对象实例上锁。
尽量不要使⽤ synchronized(String a) 因为 JVM 中，字符串常量池具有缓存功能！

对象单例模式

1.懒汉模式

2.饿汉模式

synchronized底层实现原理

synchronized 关键字底层原理属于 JVM 层⾯。

synchronized 同步语句块的实现使⽤的是 monitorenter 和 monitorexit 指令，其中

monitorenter 指令指向同步代码块的开始位置， monitorexit 指令则指明同步代码块的结束位

置。

当执⾏ monitorenter 指令时，线程试图获取锁也就是获取 对象监视器 monitor 的持有权。
在monitor内部有三个属性，分别是owner、entrylist、waitset。其中owner是关联的获得锁的线程，并且只能关联一个线程；entrylist关联的是处于阻塞状态的线程；waitset关联的是处于Waiting状态的线程