JAVA-03-2023年210道面试题归纳之Java并发（一）（连载中）

star bob

已于 2023-04-29 17:30:58 修改

阅读量129

点赞数

分类专栏： 2023面试攻略文章标签： java jvm 面试

于 2023-04-29 17:30:38 首次发布

本文链接：https://blog.youkuaiyun.com/yuhaomao/article/details/130418535

版权

2023面试攻略专栏收录该内容

6 篇文章

订阅专栏

JAVA-03-2023年210道面试题归纳之Java并发（一）（连载中）

34.线程的生命周期？线程有几种状态
35.sleep()、wait()、join()、yieId()之间的区别
36.对线程安全的理解
37.Thread和Runnable的区别
38.对守护线程的理解
39.ThreadLocal的底层原理
40.并发、并行、串行之间的区别
41.并发的三大特征
42.Java死锁如何避免？
43.如何理解volatile关键字
44.为什么用线程池？具有哪些参数？
45.线程的底层工作原理
46.线程池中队列的作用？为什么是先添加队列而不是先创建最大线程数？
47.线程池中复用原理
48.ReentranLock中的公平锁和非公平锁的底层实现
49.ReentrantLock中tryLock和lock方法的区别

34.线程的生命周期？线程有几种状态

线程通常有五种状态，创建，就绪，运行，阻塞和死亡状态：

新建状态（New）：新创建一个线程对象
就绪状态（Runnabel）：线程对象创建后，其他线程调用了该对象的start方法，该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。
可运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。
阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行，直到线程进入就绪状态，才有机会转到运行状态。
死亡状态（Dead）：线程执行完了或者因异常退出了run方法，该线程结束生命周期。

阻塞情况又分为三种：

等待阻塞：运行的线程执行wait方法，该线程会释放占有的所有资源，JVM会把该线程放入“等待池”中。进入这个状态后，是不能自动唤醒的，必须依靠其他线程调用notify或者notifyAll方法才能被唤醒，wait是Object类的方法
同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。
其他阻塞：运行的线程执行sleep或者join方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep状态超时时、join等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。sleep是Thread类的方法。

35.sleep()、wait()、join()、yieId()之间的区别

锁池：所有需要竞争同步锁的线程都会放在锁池当中，比如当前对象的锁已经被其中一个线程得到，则其他线程需要在这个锁池进行等待，当前面的线程释放同步锁后锁池中的线程区竞争同步锁，当某个线程的到后会进入就绪队列进行等待cpu资源分配。

等待池：当我们调用了wait()方法后，线程会放到等待池中，等待池的线程是不会去竞争同步锁。只有调用了notify()或notifyAll()后等待池的线程才会开始去竞争锁，notify()是随机从等待池选出一个线程放到锁池，而notifyAll()是将等待池的所有线程放到锁池当中

sleep是Thread类的静态本地方法，wait是Object类的本地方法。
sleep方法不会释放lock，但是wait会释放，而且会加入到等待队列中。

sleep就是把cpu的执行资格和执行权释放出去，不再运行此线程，当定时时间结束再取回cpu资源，参与cpu的调度，获取到cpu资源后就可以继续运行了。而如果sleep时该线程有锁，那么sleep不会释放这个锁，而是把锁带着进入了冻结状态，也就是说其他需要这个锁的线程根本不可能获取到这个锁。也就是说无法执行程序。如果在睡眠期间其他线程调用了这个线程的interrupt方法，那么这个线程也会跑出interruptException异常返回，这点和wait是一样的
sleep方法不依赖同步器synchronized，但是wait需要依赖synchronized关键字。
sleep不需要被唤醒（休眠之后推出阻塞），但是wait需要（不指定时间需要被别人中断）。
sleep一般用于当前线程休眠，或者轮循暂停操作，wait则多用于多线程之间的通信。
sleep会让出cpu执行时间且强制上下文切换，而wait则不一定，wait后可能还是有机会重新竞争到锁继续执行的。
yieId()执行后线程直接进入就绪状态，放上释放cpu的执行权，但是依然保留了cpu的执行资格，所以有可能cpu下次进行线程调度还会让这个线程货渠道执行权继续执行
join()执行后线程进入阻塞状态，例如在线程B中调用线程A的join()，那么线程B会进入到阻塞队列，知道线程A结束或者中断线程

main() {
	Thread t = new Thread(new Runnable(){
		@Override
		run(){
			Thread.sleep(3000);
			sout("start");
		}
	});
	t.start();
	t.join();
	// 这行代码必须要等t线程执行完，才会执行
	sout("end");
}

36.对线程安全的理解

不是线程安全，应该是叫做内存安全，堆事共享内存，可以被所有线程访问，当多个线程访问一个对象时，如果不用进行额外的同步控制或其他的协调操作，调用这个对象的行为都可以获得正确的结果，我们就说这个对象是线程安全的。

堆是进程和线程共有的空间，分全局堆和局部堆。全局堆就是所有没有分配的空间，局部堆就是用户分配的空间。堆在操作系统堆进程初始化的时候分配，运行过程中也可以向系统要额外的堆，但是用完要还给操作系统，要不然就是内存泄漏。在java中，堆是jvm所管理的内存最大的一块，是所有线程共享的一块内存区域，在jvm启动时创建。堆所在的内存区域的唯一目的就是存放对象实例，几乎所有的对象实例以及数组都在这里分配内存。

栈是每个线程独有的。保存其运行状态和局部自动变量的。栈在线程开始的时候初始化，每个线程的栈互相独立，因此，栈是线程安全的。操作系统在切换线程的时候会自动切换栈。栈空间不需要在高级语言里面显式的分配和释放。

目前主流的操作系统都是多任务的，即多个进程同时运行。为保证安全，每个进程只能访问分配给自己的内存空间，而不能访问别的进程，这是由操作系统保障的。

在每个进程的内存空间中都会有一块特殊的公共区域，通常称为堆（内存）。进程内的所有线程都可以访问到该区域，这就是造成问题的潜在原因。

37.Thread和Runnable的区别

Thread和Runnable的实质是继承关系，没有可比性。无论使用Runnable还是Thread，都会new Thread，然后执行run方法。用法上，如果有复杂的线程操作需求，那就选择吉成Thread，如果只是简单的执行一个任务，那就实现Runnable。

// 多卖出一倍的票
main(){
	new MyThread().start();
	new MyThread().start();
}

static class MyThread extends Thread{
	private int ticket = 5;
	public void run(){
		while(true){
			sout("ticket=" + ticket--);
			if(ticket < 0){
				break;
			}
		}
	}
}

// 正常卖出
mian(){
	MyThread mt = new MyThread();
	new Thread(mt).start();
	new Thread(mt).start();
}

static class MyThread extends Thread{
	private int ticket = 5;
	public void run(){
		while(true){
			sout("ticket=" + ticket--);
			if(ticket < 0){
				break;
			}
		}
	}
}

原因是：MyThread创建了两个实例，自然会卖出两倍，属于用法错误

38.对守护线程的理解

守护线程：为所有非守护线程提供服务的线程；任何一个守护线程都是整个JVM中所有非守护线程的保姆；

守护线程类似于整个进程的一个默默无闻的小喽喽；它的生死无关重要，它却依赖整个进程而运行；哪天其他线程结束了，没有要执行的了，线程就结束了，理都没理守护线程，就把它中断了；

注意：由于守护线程的终止是自身无法控制的，因此千万不要把IO、File等重要操作逻辑分配给它；因为它不靠谱；

守护线程的作用是什么？
举例，GC垃圾回收线程：就是一个经典的守护线程，当我们的程序中不再有任何运行的Thread，程序就不会再产生垃圾，垃圾回收器也就无事可做，所以当垃圾回收线程是JVM上仅剩的线程时，垃圾回收线程会自动离开。它始终在低级别的状态中运行，用于实时监控和管理系统中的可回收资源。
应用场景：

来为其他线程提供服务支持的情况；
或者在任何情况下，程序结束时，这个县城必须正常且立刻关闭，就可以作为守护线程来使用；反之，如果一个正在执行某个操作的线程必须要正确的关闭掉否则就会出现不好的后果，那么这个线程就不能是守护线程，而是用户线程。通常都是些关键的事物，比如说，数据库录入或者更新，这些操作都是不能中断的。

thread.setDeamon(true)必须在thread.start()之前设置，否则会跑出一个IIegalThreadStateException异常，你不能把正在运行的常规线程设置为守护线程。

在Deamon线程中产生的新县城也是Deamon的。

守护现场不能用于去访问固有资源，比如读写操作或者计算逻辑。因为它会在任何时候甚至一个操作的中间发生中断。

Java自带的多线程框架，比如ExeutorService，会将守护线程转为用户线程，所以如果要使用后台线程就不能用Java的线程池。

39.ThreadLocal的底层原理

ThreadLocal是Java中所提供的线程本地存储机制，可以利用该机制将数据缓存在某个线程内部，该线程可以在任何时刻、任何方法中获取缓存的数据。
ThreadLocal底层是通过ThreadLocalMap来实现的，每个Thread对象（注意不是ThreadLocal对象）中都存在一个ThreadLocalMap，Map的key为ThreadLocal对象，Map的value为需要缓存的值
如果在线程池中使用ThreadLocal会造成内存泄漏，因为当ThreadLocal对象使用完之后，应该要把设置的Key，value，也就是Entry对象进行回收，但是线程池中的线程不会回收，而线程对象是通过强引用只想ThreadLocalMap，ThreadLocalMap也是通过强引用指向Entry对象，线程不被回收，Entry对象也就不会被回收，从而出现内存泄露，解决办法是，在使用了ThreadLocal对象之后，手动调用ThreadLocal的remove方法，手动清除Entry对象
ThreadLocal经典的场景就是连接管理（一个线程持有一个链接，该链接对象可以在不同的方法之间传递，线程之间不共享同一个链接）

40.并发、并行、串行之间的区别

串行在时间上不可能发生重叠，前一个任务设定，下一个任务就只能等着
并行在时间上是重叠的，两个任务在同一个时刻互不干扰的同时执行。
并发允许两个任务彼此干扰。统一时间点、只有一个任务允许，交替执行。

41.并发的三大特征

原子性
原子性是指在一个操作中cpu不可以在中途暂停然后在调度，即不被中断操作，要不全部执行完成，要不都不执行。就好比转账，从账户A向账户B转1000元，那么必然包括2个操作：从账户A减去1000元，往账户B加上1000元。2个操作必须全部完成

private long count = 0;

public void calc(){
	count++;
}

将count从主存读到工作内存中的副本中
+1运算
将结果写入工作内存
将工作内存的值刷回主存（什么时候刷入由操作系统决定，不确定的）

那程序中原子性指的是最小的操作但愿，比如自增操作，它本身其实并不是原子性操作，分了3步的，包括读取变量的原始值、进行加1操作，写入工作内存。所以在多线程中，有可能一个线程还没自增完，可能才执行到第二部，另一个线程就已经读取了值，导致结果错误。那如果我们能保证自增操作是一个原子性操作，那么就能保证其他现场读取到的一定是自增后的数据。

关键字：synchronized

可见性
当多个线程访问同一个变量时，一个线程修改了这个变量值，其他线程能够立即看到修改的值。
若两个现场在不同的cpu，那么线程1改变了i的值还没啥心到主存，线程2又使用了i，那么这个i肯定还是之前的，线程1对变量的修改线程没看到这就是可见性问题。

// 线程1
boolean stop = false;
while (!stop) {
	doSometing();
}

// 线程2
stop = true;

如果线程2改变了stop的值，线程1一定会停止吗？不一定。当线程2更改了stop变量之后，但是还没来得及写入主存当中，线程2转去做其他事情了，那么线程1由于不知道线程2对stop变量的更改，因此还会一直循环下去。

关键字：volatile、synchronized、final

有序性
虚拟机在进行代码编译时，对于那些改变顺序之后不会对最终结果造成影响的代码，虚拟机不一定会按照我们写的代码顺序来执行，有可能将他们重排序。实际上，对于有些代码进行重排序之后，虽然对变量的值没有造成影响，但有可能出现线程安全问题。

int a = 0;
bool flag = false;

write() {
	a = 2; // 1
	flag = true; // 2
}

multiply() {
	if(flag) { // 3
		int ret = a * a; // 4
	}
}

write方法里的1和2做了重排序，线程1先对flag赋值为true，随后执行到线程2，ret直接计算出结果，结果再到线程1，这时候a才赋值为2，很明显迟了一步

关键字：volatile、synchronized

volatile本身就包含了禁止指令重排序的语义，而synchronized关键字是由“一个变量在同一时刻只允许一条线程对其进行lock操作”这条规则明确的。。

synchronized关键字同时满足以上三种特性，但是volatile关键字不满足原子性。

在某些情况下，volatile的同步机制的性能确实要优于锁（使用synchronized关键字或java.util.concurrent包里面的锁），因为volatile的总开销要比锁低。

我们判断使用volatile还是加锁的唯一依据就是volatile的语义能否满足使用的场景（原子性）。

42.Java死锁如何避免？

造成死锁的几个原因：

一个资源每次只能被一个线程使用
一个线程在阻塞等待某个资源时，不释放已占有资源
一个线程已经获得的资源，在未使用完之前，不能被强行剥夺
若干线程形成头尾相接的循环等待资源关系
这是造成死锁必要的四个条件，如果要避免死锁，只需要不满足其中一个条件即可。而其中前3个条件是作为锁要符合的条件，所以要避免死锁就需要打破第4个条件，不出现循环等待锁的关系。

在开发过程中：

要注意加锁的顺序，保证每个线程按照同样的顺序进行加锁
要注意加速的时限，可以针对所设置一个超时时间
要注意死锁检查，这是一种预防机制，确保在第一时间发现死锁并进行解决

43.如何理解volatile关键字

保证被volatile修饰的共享变量对所有线程总是可见的，也就是当一个线程修改了一个被volatile修饰共享变量的值，新值总是可以被其他线程立即得知。

// 线程1
boolean stop = false;
while (!stop) {
	doSometing();
}

// 线程2
stop = true;

如果线程2改变了stop值，线程1一定会停止么？
不一定，当线程2更改了stop变量值之后，但是还没来得及去写入到主存当中，线程2转去做其他事情了，那么线程1由于不知道线程2对stop变量的更改，因此还会一直循环下去。

禁止指令重排序优化

int a = 0;
bool flag = false;

write() {
	a = 2; // 1
	flag = true; // 2
}

multiply() {
	if(flag) { // 3
		int ret = a * a; // 4
	}
}

write方法里的1和2做了重排序，线程1先对flag赋值为true，随后执行到线程2，ret直接计算出结果，再到线程1，这时候a才赋值为2，很明显迟了一步。但是用volatile修饰之后就变得不一样了：

使用volatile关键字会强行将修改的值立即写入到主存；
使用volatile关键字，当线程2进行修改时，会导致线程1的工作内容中缓存变量stop的缓存无效（反应到硬件层的话，就是CPU的L1或者L2缓存中对应的缓存无效）；
由于线程1的工作内存中缓存变量stop的缓存无效，所以线程1再读取变量stop的值时会去主存读取。

inc++；这其实是两个步骤，先加加，然后再赋值。不是原子性操作，所以volatile不能保证线程安全。

44.为什么用线程池？具有哪些参数？

1、降低资源消耗：提高线程利用率，降低创建和销毁线程的消耗。
2、提高相应速度：任务来了，直接有线程可用可执行，而不是先创建线程，再执行。
3、提高线程的可管理性：线程时稀缺资源，使用线程池可以统一分配调优监控。

corePoolSize：代表核心线程数，也就是正常情况下创建工作的线程数，这些线程创建后并不会消除，而是一种常驻线程
maxinumPoolSize：代表的是最大线程数，它与核心线程数相对应，表示最大允许被创建的线程数，比如当前任务多，将核心线程数都用完了，还无法满足需求时，此时就会创建新的线程，但是线程池内线程总数不会超过最大线程数
keepAliveTime、unit：表示超出核心线程数之外的线程空闲的存活时间，也就是核心线程不会消除，但是超出核心线程数的部分线程如果空闲一定的时间则会被消除，我们可以通过setKeepAliveTime来设置空闲时间
workQueue：用来存放待执行的任务，假设我们现在的核心线程已经被使用，还有任务进来则全部放入队列，直到整个队列被放满单任务还在持续进入择会开始创建新的线程。
ThreadFactory：实际上是一个线程工厂，用来生产线程执行任务。我们可以选择使用默认的创建工厂，产生的线程都在同一个组内，拥有相同的优先级，且都不是守护线程，当然我们也可以选择自定义线程工厂，一般我们会根据业务来制定不同的线程工厂。
Handler：任务拒绝策略，有两种情况，第一种是当我们调用shutdown等方法关闭线程池后，这时候即使线程池内部还有没执行完的任务正在执行，但由于线程池已经关闭，我们再继续想线程提交任务就会遭到拒绝。另一种情况就是当达到最大线程数，线程池已经没有能力继续处理新提交的任务时，这是也就拒绝。

45.线程的底层工作原理

线程池内部是通过队列+线程实现的，当我们利用线程池执行任务时：

如果此时线程池中的线程数小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。
如果此时线程池中的线程数量等于corePoolSize，但是缓冲队列workQueue未满，那么任务会被放入缓冲队列。
如果此时线程数中的线程数量大于等于corePoolSize，缓冲队列workQueue满的，并且线程池中的数量小于maxnumPoolSize，建立新的线程来处理被添加的任务。
如果此时线程数中的线程数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maxNumPoolSize，那么通过handler所指定的策略来处理此任务。
当线程池中的线程数量大于corePoolSize时，如果某线程空闲时间超过KeepAliveTime，线程将被终止。这样，线程池可以动态的调整池中的线程数

46.线程池中队列的作用？为什么是先添加队列而不是先创建最大线程数？

1、一般的队列只能保证一个有限长度的缓冲区，如果超出了缓冲长度，就无法保留当前的任务了，阻塞队列通过阻塞可以保留住当前想要继续入队的任务。

阻塞对了可以保证任务队列中没有任务时，阻塞获取任务的线程，使得线程进入wait状态，释放cpu资源。

阻塞队列自带阻塞和唤醒功能，不需要额外处理，无任务执行时，线程池利用阻塞队列的take方法挂起，从而维持核心线程的存活、不至于一直占用cpu资源

2、在创建新线程的时候，是要获取全局锁的，这个时候其他的就得阻塞，影响了整体效率。

就好比一个企业里面有10个（core）正式工的名额，最多招10个正式工，要是任务超过正式工人数（task > core）的情况下，工厂领导（线程池）不是首先扩招工人，还是这10个人，但是任务可以稍微积压一下，即先放入队列中。10个正式员工慢慢干，迟早会干完的，要是任务还在继续增加，超过正式工的加班忍耐极限了（队列满了），就得招外包帮忙了（注意是临时工）要是正式工加上外包还是不能完成任务，那新来的任务就会被领导拒绝了（线程池的拒绝策略）。

47.线程池中复用原理

线程池将线程和任务解耦，线程是线程，任务是任务，摆脱了之前通过Thread创建线程时的一个线程必须对应一个任务的限制

在线程池中，同一个线程可以从阻塞队列中不断获取新任务来执行，其核心原理在于线程池对Thread进行了封装，并不是每次任务都会调用Thread.start()来创建新线程，而是让每个线程去执行一个“循环任务”，在这个“循环任务”中不停检查是否有任务需要被执行，如果有则直接执行，也就是调用任务中的run方法，将run方法当成一个普通的方法执行，通过这种方式只使用固定的线程就将所有任务的run方法串联起来。