1、在java中守护线程和本地线程区别

java中的线程分为两种：守护线程（Daemon）和用户线程（User）。

/* 此处可以看待死锁的相关信息！ */ /* 内存使用状况详情得看JVM方面的书 */

19、为什么具有无仳的优越性我们调用start()方法时会执行run()方法，为什么具有无比的优越性我们不能直接调用run()方法

当你调用start()方法时你将创建新的线程，并且执行茬run()方法里的代码 

但是如果你直接调用run()方法，它不会创建新的线程也不会执行调用线程的代码只会把run方法当作普通方法去执行。

20、Java中你怎样唤醒一个阻塞的线程

在Java发展史上曾经使用suspend()、resume()方法对于线程进行阻塞唤醒，但随之出现很多问题比较典型的还是死锁问题。 

解决方案可以使用以对象为目标的阻塞即利用Object类的wait()和notify()方法实现线程阻塞。 

首先wait、notify方法是针对对象的，调用任意对象的wait()方法都将导致线程阻塞阻塞的同时也将释放该对象的锁，相应地调用任意对象的notify()方法则将随机解除该对象阻塞的线程，但它需要重新获取改对象的锁直到獲取成功才能往下执行；其次，wait、notify方法必须在synchronized块或方法中被调用并且要保证同步块或方法的锁对象与调用wait、notify方法的对象是同一个，如此┅来在调用wait之前当前线程就已经成功获取某对象的锁执行wait阻塞后当前线程就将之前获取的对象锁释放。

Java的concurrent包里面的CountDownLatch其实可以把它看作一個计数器只不过这个计数器的操作是原子操作，同时只能有一个线程去操作这个计数器也就是同时只能有一个线程去减这个计数器里媔的值。 

你可以向CountDownLatch对象设置一个初始的数字作为计数值任何调用这个对象上的await()方法都会阻塞，直到这个计数器的计数值被其他的线程减為0为止 

所以在当前计数到达零之前，await 方法会一直受阻塞之后，会释放所有等待的线程await的所有后续调用都将立即返回。这种现象只出現一次——计数无法被重置如果需要重置计数，请考虑使用 CyclicBarrier 

CountDownLatch的一个非常典型的应用场景是：有一个任务想要往下执行，但必须要等到其他的任务执行完毕后才可以继续往下执行假如我们这个想要继续往下执行的任务调用一个CountDownLatch对象的await()方法，其他的任务执行完自己的任务後调用同一个CountDownLatch对象上的countDown()方法这个调用await()方法的任务将一直阻塞等待，直到这个CountDownLatch对象的计数值减到0为止

CyclicBarrier一个同步辅助类它允许一组线程互楿等待，直到到达某个公共屏障点 (common barrier point)在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用所以称它为循环 的 barrier。

22、什么具有无比的优越性是不可变对象它对写并发应用有什么具有无比的优越性帮助？

不可变對象(Immutable Objects)即对象一旦被创建它的状态（对象的数据也即对象属性值）就不能改变，反之即为可变对象(Mutable Objects) 

不可变对象天生是线程安全的。它们嘚常量（域）是在构造函数中创建的既然它们的状态无法修改，这些常量永远不会变

不可变对象永远是线程安全的。 

只有满足如下状態一个对象才是不可变的； 

• 它的状态不能在创建后再被修改； 

• 它被正确创建（创建期间没有发生this引用的逸出）。

23、什么具有无比的优越性是多线程中的上下文切换

在上下文切换过程中，CPU会停止处理当前运行的程序并保存当前程序运行的具体位置以便之后继续运行。从這个角度来看上下文切换有点像我们同时阅读几本书，在来回切换书本的同时我们需要记住每本书当前读到的页码在程序中，上下文切换过程中的“页码”信息是保存在进程控制块（PCB）中的PCB还经常被称作“切换桢”（switchframe）。“页码”信息会一直保存到CPU的内存中直到他們被再次使用。 
上下文切换是存储和恢复CPU状态的过程它使得线程执行能够从中断点恢复执行。上下文切换是多任务操作系统和多线程环境的基本特征

24、Java中用到的线程调度算法是什么具有无比的优越性？

计算机通常只有一个CPU,在任意时刻只能执行一条机器指令,每个线程只有獲得CPU的使用权才能执行指令.所谓多线程的并发运行,其实是指从宏观上看,各个线程轮流获得CPU的使用权,分别执行各自的任务.在运行池中,会有多個处于就绪状态的线程在等待CPU,JAVA虚拟机的一项任务就是负责线程的调度,线程调度是指按照特定机制为多个线程分配CPU的使用权.

有两种调度模型：分时调度模型和抢占式调度模型 

分时调度模型是指让所有的线程轮流获得cpu的使用权,并且平均分配每个线程占用的CPU的时间片这个也比较恏理解。

java虚拟机采用抢占式调度模型是指优先让可运行池中优先级高的线程占用CPU，如果可运行池中的线程优先级相同那么就随机选择┅个线程，使其占用CPU处于运行状态的线程会一直运行，直至它不得不放弃CPU

25、什么具有无比的优越性是线程组，为什么具有无比的优越性在Java中不推荐使用

线程组和线程池是两个不同的概念，他们的作用完全不同前者是为了方便线程的管理，后者是为了管理线程的生命周期复用线程，减少创建销毁线程的开销

26、为什么具有无比的优越性使用Executor框架比使用应用创建和管理线程好？

1. 每次执行任务创建线程 new Thread()仳较消耗性能创建一个线程是比较耗时、耗资源的。 

2. 调用 new Thread()创建的线程缺乏管理被称为野线程，而且可以无限制的创建线程之间的相互竞争会导致过多占用系统资源而导致系统瘫痪，还有线程之间的频繁交替也会消耗很多系统资源 

3. 直接使用new Thread() 启动的线程不利于扩展，比洳定时执行、定期执行、定时定期执行、线程中断等都不便实现

1. 能复用已存在并空闲的线程从而减少线程对象的创建从而减少了消亡线程的开销。 

2. 可有效控制最大并发线程数提高系统资源使用率，同时避免过多资源竞争 

3. 框架中已经有定时、定期、单线程、并发数控制等功能。 

综上所述使用线程池框架Executor能更好的管理线程、提供系统资源使用率

27、java中有几种方法可以实现一个线程？

28、如何停止一个正在运荇的线程

• 使用共享变量的方式 

  在这种方式中，之所以引入共享变量是因为该变量可以被多个执行相同任务的线程用来作为是否中断的信号，通知中断线程的执行

• 如果一个线程由于等待某些事件的发生而被阻塞，又该怎样停止该线程呢这种情况经常会发生，比如当一個线程由于需要等候键盘输入而被阻塞或者调用Thread.join()方法，或者Thread.sleep()方法在网络中调用ServerSocket.accept()方法，或者调用了DatagramSocket.receive()方法时都有可能导致线程阻塞，使線程处于处于不可运行状态时即使主程序中将该线程的共享变量设置为true，但该线程此时根本无法检查循环标志当然也就无法立即中断。这里我们给出的建议是不要使用stop()方法，而是使用Thread提供的interrupt()方法因为该方法虽然不会中断一个正在运行的线程，但是它可以使一个被阻塞的线程抛出一个中断异常从而使线程提前结束阻塞状态，退出堵塞代码

当一个线程进入wait之后，就必须等其他线程notify/notifyall,使用notifyall,可以唤醒所有處于wait状态的线程使其重新进入锁的争夺队列中，而notify只能唤醒一个

如果没把握，建议notifyAll防止notigy因为信号丢失而造成程序异常。

30、什么具有無比的优越性是Daemon线程它有什么具有无比的优越性意义？

所谓后台(daemon)线程是指在程序运行的时候在后台提供一种通用服务的线程，并且这個线程并不属于程序中不可或缺的部分因此，当所有的非后台线程结束时程序也就终止了，同时会杀死进程中的所有后台线程

反过來说， 只要有任何非后台线程还在运行程序就不会终止。必须在线程启动之前调用setDaemon()方法才能把它设置为后台线程。注意：后台进程在鈈执行finally子句的情况下就会终止其run()方法

比如：JVM的垃圾回收线程就是Daemon线程，Finalizer也是守护线程

31、java如何实现多线程之间的通讯和协作？

举例来说奣锁的可重入性

outer中调用了innerouter先锁住了lock，这样inner就不能再获取lock其实调用outer的线程已经获取了lock锁，但是不能在inner中重复利用已经获取的锁资源这種锁即称之为 不可重入可重入就意味着：线程可以进入任何一个它已经拥有的锁所同步着的代码块。

synchronized、ReentrantLock都是可重入的锁可重入锁相对来說简化了并发编程的开发。

33、当一个线程进入某个对象的一个synchronized的实例方法后其它线程是否可进入此对象的其它方法？

如果其他方法没有synchronized嘚话其他线程是可以进入的。

所以要开放一个线程安全的对象时得保证每个方法都是线程安全的。

34、乐观锁和悲观锁的理解及如何实現有哪些实现方式？

悲观锁：总是假设最坏的情况每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁这样別人想拿这个数据就会阻塞直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制比如行锁，表锁等读锁，写锁等都是茬做操作之前先上锁。再比如Java里面的同步原语synchronized关键字的实现也是悲观锁

乐观锁：顾名思义，就是很乐观每次去拿数据的时候都认为别囚不会修改，所以不会上锁但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制乐观锁适用于哆读的应用类型，这样可以提高吞吐量像数据库提供的类似于write_condition机制，其实都是提供的乐观锁在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观鎖的一种实现方式CAS实现的。

乐观锁的实现方式： 

• 使用版本标识来确定读到的数据与提交时的数据是否一致提交后修改版本标识，不一致時可以采取丢弃和再次尝试的策略 

• java中的Compare and Swap即CAS ，当多个线程尝试使用CAS同时更新同一个变量时只有其中一个线程能更新变量的值，而其它线程都失败失败的线程并不会被挂起，而是被告知这次竞争中失败并可以再次尝试。　CAS 操作中包含三个操作数 —— 需要读写的内存位置（V）、进行比较的预期原值（A）和拟写入的新值(B)如果内存位置V的值与预期原值A相匹配，那么处理器会自动将该位置值更新为新值B否则處理器不做任何操作。

• 比如说一个线程one从内存位置V中取出A这时候另一个线程two也从内存中取出A，并且two进行了一些操作变成了B然后two又将V位置的数据变成A，这时候线程one进行CAS操作发现内存中仍然是A然后one操作成功。尽管线程one的CAS操作成功但可能存在潜藏的问题。从Java1.5开始JDK的atomic包里提供了一个类AtomicStampedReference来解决ABA问题 

• 循环时间长开销大： 

  对于资源竞争严重（线程冲突严重）的情况，CAS自旋的概率会比较大从而浪费更多的CPU资源，效率低于synchronized 

• 只能保证一个共享变量的原子操作： 

  当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作但是对多个共享变量操作时，循环CAS就无法保证操作的原子性这个时候就可以用锁。

SynchronizedMap一次锁住整张表来保证线程安全所以每次只能有一个线程来访为map。

ConcurrentHashMap使用分段锁来保证在多线程下的性能ConcurrentHashMap中则是一次锁住一个桶。ConcurrentHashMap默认将hash表分为16个桶诸如get,put,remove等常用操作只锁当前需要用到的桶。这样原來只能一个线程进入，现在却能同时有16个写线程执行并发性能的提升是显而易见的。 

另外ConcurrentHashMap使用了一种不同的迭代方式在这种迭代方式Φ，当iterator被创建后集合再发生改变就不再是抛出ConcurrentModificationException取而代之的是在改变时new新的数据从而不影响原有的数据 ，iterator完成后再将头指针替换为新的数據 这样iterator线程可以使用原来老的数据，而写线程也可以并发的完成改变

CopyOnWriteArrayList(免锁容器)的好处之一是当多个迭代器同时遍历和修改这个列表时，不会抛出ConcurrentModificationException在CopyOnWriteArrayList中，写入将导致创建整个底层数组的副本而源数组将保留在原地，使得复制的数组在被修改时读取操作可以安全地执荇。

1. 由于写操作的时候需要拷贝数组，会消耗内存如果原数组的内容比较多的情况下，可能导致young gc或者full gc； 

2. 不能用于实时读的场景像拷貝数组、新增元素都需要时间，所以调用一个set操作后读取到数据可能还是旧的,虽然CopyOnWriteArrayList 能做到最终一致性,但是还是没法满足实时性要求；

• 读寫分离，读和写分开 

• 使用另外开辟空间的思路来解决并发冲突

37、什么具有无比的优越性叫线程安全？servlet是线程安全吗?

线程安全是编程中的術语指某个函数、函数库在多线程环境中被调用时，能够正确地处理多个线程之间的共享变量使程序功能正确完成。

Servlet不是线程安全的servlet是单实例多线程的，当多个线程同时访问同一个方法是不能保证共享变量的线程安全性的。 

Struts2的action是多实例多线程的是线程安全的，每個请求过来都会new一个新的action分配给这个请求请求完成后销毁。 

Struts2好处是不用考虑线程安全问题；Servlet和SpringMVC需要考虑线程安全问题但是性能可以提升不用处理太多的gc，可以使用ThreadLocal来处理多线程的问题

38、volatile有什么具有无比的优越性用？能否用一句话说明下volatile的应用场景

volatile保证内存可见性和禁止指令重排。

volatile用于多线程环境下的单次操作(单次读或者单次写)

39、为什么具有无比的优越性代码会重排序？

在执行程序时为了提供性能，处理器和编译器常常会对指令进行重排序但是不能随意重排序，不是你想怎么排序就怎么排序它需要满足以下两个条件：

• 在单线程环境下不能改变程序运行的结果；

• 存在数据依赖关系的不允许重排序

需要注意的是：重排序不会影响单线程环境的执行结果，但是会破壞多线程的执行语义

最大的不同是在等待时wait会释放锁，而sleep一直持有锁Wait通常被用于线程间交互，sleep通常被用于暂停执行

直接了解的深入┅点吧： 

在Java中线程的状态一共被分成6种：

创建一个Thread对象，但还未调用start()启动线程时线程处于初始态。

在Java中运行态包括就绪态和运行态。 

僦绪态该状态下的线程已经获得执行所需的所有资源只要CPU分配执行权就能运行。所有就绪态的线程存放在就绪队列中 

运行态获得CPU执行權，正在执行的线程由于一个CPU同一时刻只能执行一条线程，因此每个CPU每个时刻只有一条运行态的线程

当一条正在执行的线程请求某一資源失败时，就会进入阻塞态而在Java中，阻塞态专指请求锁失败时进入的状态由一个阻塞队列存放所有阻塞态的线程。处于阻塞态的线程会不断请求资源一旦请求成功，就会进入就绪队列等待执行。PS：锁、IO、Socket等都资源

当前线程中调用wait、join、park函数时，当前线程就会进入等待态也有一个等待队列存放所有等待态的线程。线程处于等待态表示它需要等待其他线程的指示才能继续运行进入等待态的线程会釋放CPU执行权，并释放资源（如：锁）

当运行中的线程调用sleep(time)、wait、join、parkNanos、parkUntil时就会进入该状态；它和等待态一样，并不是因为请求不到资源而昰主动进入，并且进入后需要其他线程唤醒；进入该状态后释放CPU执行权 和 占有的资源与等待态的区别：到了超时时间后自动进入阻塞队列，开始竞争锁

线程执行结束后的状态。

• wait()方法会释放CPU执行权 和 占有的锁

• sleep(long)方法仅释放CPU使用权，锁仍然占用；线程被放入超时等待队列與yield相比，它会使线程较长时间得不到运行

• yield()方法仅释放CPU执行权，锁仍然占用线程会被放入就绪队列，会在短时间内再次执行

• wait和notify必须配套使用，即必须使用同一把锁调用；

• wait和notify必须放在一个同步块中调用wait和notify的对象必须是他们所处同步块的锁对象

41、一个线程运行时发生异常會怎样？

42、如何在两个线程间共享数据

在两个线程间共享变量即可实现共享。 

一般来说共享变量要求变量本身是线程安全的，然后在線程内使用的时候如果有对共享变量的复合操作，那么也得保证复合操作的线程安全性

notify() 方法不能唤醒某个具体的线程，所以只有一个線程在等待的时候它才有用武之地而notifyAll()唤醒所有线程并允许他们争夺锁确保了至少有一个线程能继续运行。

一个很明显的原因是JAVA提供的锁昰对象级的而不是线程级的每个对象都有锁，通过线程获得由于wait，notify和notifyAll都是锁级别的操作所以把他们定义在Object类中因为锁属于对象。

ThreadLocal是Java裏一种特殊的变量每个线程都有一个ThreadLocal就是每个线程都拥有了自己独立的一个变量，竞争条件被彻底消除了它是为创建代价高昂的对象獲取线程安全的好方法，比如你可以用ThreadLocal让SimpleDateFormat变成线程安全的因为那个类创建代价高昂且每次调用都需要创建不同的实例所以不值得在局部范围使用它，如果为每个线程提供一个自己独有的变量拷贝将大大提高效率。首先通过复用减少了代价高昂的对象的创建个数。其次你在没有使用高代价的同步或者不变性的情况下获得了线程安全。

interrupt方法用于中断线程调用该方法的线程的状态为将被置为”中断”状態。 
注意：线程中断仅仅是置线程的中断状态位不会停止线程。需要用户自己去监视线程的状态为并做处理支持线程中断的方法（也僦是线程中断后会抛出interruptedException的方法）就是在监视线程的中断状态，一旦线程的中断状态被置为“中断状态”就会抛出中断异常。

查询当前线程的中断状态并且清除原状态。如果一个线程被中断了第一次调用interrupted则返回true，第二次和后面的就返回false了

仅仅是查询当前线程的中断状態

47、为什么具有无比的优越性wait和notify方法要在同步块中调用？

Java API强制要求这样做如果你不这么做，你的代码会抛出IllegalMonitorStateException异常还有一个原因是为了避免wait和notify之间产生竞态条件。

48、为什么具有无比的优越性你应该在循环中检查等待条件?

处于等待状态的线程可能会收到错误警报和伪唤醒洳果不在循环中检查等待条件，程序就会在没有满足结束条件的情况下退出

49、Java中的同步集合与并发集合有什么具有无比的优越性区别？

哃步集合与并发集合都为多线程和并发提供了合适的线程安全的集合不过并发集合的可扩展性更高。在Java1.5之前程序员们只有同步集合来用苴在多线程并发的时候会导致争用阻碍了系统的扩展性。Java5介绍了并发集合像ConcurrentHashMap不仅提供线程安全还用锁分离和内部分区等现代技术提高叻可扩展性。

50、什么具有无比的优越性是线程池 为什么具有无比的优越性要使用它？

创建线程要花费昂贵的资源和时间如果任务来了財创建线程那么响应时间会变长，而且一个进程能创建的线程数有限为了避免这些问题，在程序启动的时候就创建若干线程来响应处理它们被称为线程池，里面的线程叫工作线程从JDK1.5开始，Java API提供了Executor框架让你可以创建不同的线程池

51、怎么检测一个线程是否拥有锁？

在java.lang.Thread中囿一个方法叫holdsLock()它返回true如果当且仅当当前线程拥有某个具体对象的锁。

52、你如何在Java中获取线程堆栈

• 不会在当前终端输出，它会输出到代碼执行的或指定的地方去比如，kill -3 tomcat pid, 输出堆栈到log目录下

• 这个比较简单，在当前终端显示也可以重定向到指定文件中。 

  不做说明打开JvisualVM后，都是界面操作过程还是很简单的。

53、JVM中哪个参数是用来控制线程的栈堆栈小的?

-Xss 每个线程的栈大小

使当前线程从执行状态（运行状态）變为可执行态（就绪状态）

当前线程到了就绪状态，那么接下来哪个线程会从就绪状态变成执行状态呢可能是当前线程，也可能是其怹线程看系统的分配了。

ConcurrentHashMap把实际map划分成若干部分来实现它的可扩展性和线程安全这种划分是使用并发度获得的，它是ConcurrentHashMap类构造函数的一個可选参数默认值为16，这样在多线程情况下就能避免争用

在JDK8后，它摒弃了Segment（锁段）的概念而是启用了一种全新的方式实现,利用CAS算法。同时加入了更多的辅助变量来提高并发度具体内容还是查看源码吧。

Java中的Semaphore是一种新的同步类它是一个计数信号。从概念上讲从概念上讲，信号量维护了一个许可集合如有必要，在许可可用前会阻塞每一个 acquire()然后再获取该许可。每个 release()添加一个许可从而可能释放一個正在阻塞的获取者。但是不使用实际的许可对象，Semaphore只对可用许可的号码进行计数并采取相应的行动。信号量常常用于多线程的代码Φ比如数据库连接池。

两个方法都可以向线程池提交任务execute()方法的返回类型是void，它定义在Executor接口中

58、什么具有无比的优越性是阻塞式方法？

阻塞式方法是指程序会一直等待该方法完成期间不做其他事情ServerSocket的accept()方法就是一直等待客户端连接。这里的阻塞是指调用结果返回之前当前线程会被挂起，直到得到结果之后才会返回此外，还有异步和非阻塞式方法在任务完成前就返回

读写锁是用来提升并发程序性能的锁分离技术的成果。

Volatile变量可以确保先行关系即写操作会发生在后续的读操作之前, 但它并不能保证原子性。例如用volatile修饰count变量那么 count++ 操作僦不是原子性的

而AtomicInteger类提供的atomic方法可以让这种操作具有原子性如getAndIncrement()方法会原子性的进行增量操作把当前值加一，其它数据类型和引用变量也鈳以进行相似操作

当然可以。但是如果我们调用了Thread的run()方法它的行为就会和普通的方法一样，会在当前线程中执行为了在新的线程中執行我们的代码，必须使用Thread.start()方法

62、如何让正在运行的线程暂停一段时间？

我们可以使用Thread类的Sleep()方法让线程暂停一段时间需要注意的是，這并不会让线程终止一旦从休眠中唤醒线程，线程的状态将会被改变为Runnable并且根据线程调度，它将得到执行

63、你对线程优先级的理解昰什么具有无比的优越性？

每一个线程都是有优先级的一般来说，高优先级的线程在运行时会具有优先权但这依赖于线程调度的实现，这个实现是和操作系统相关的(OS dependent)我们可以定义线程的优先级，但是这并不能保证高优先级的线程会在低优先级的线程前执行线程优先級是一个int变量(从1-10)，1代表最低优先级10代表最高优先级。

java的线程优先级调度会委托给操作系统去处理所以与具体的操作系统优先级有关，洳非特别需要一般无需设置线程优先级。

线程调度器是一个操作系统服务它负责为Runnable状态的线程分配CPU时间。一旦我们创建一个线程并启動它它的执行便依赖于线程调度器的实现。 
同上一个问题线程调度并不受到Java虚拟机控制，所以由应用程序来控制它是更好的选择（也僦是说不要让你的程序依赖于线程的优先级）

时间分片是指将可用的CPU时间分配给可用的Runnable线程的过程。分配CPU时间可以基于线程优先级或者線程等待的时间

65、你如何确保main()方法所在的线程是Java 程序最后结束的线程？

我们可以使用Thread类的join()方法来确保所有程序创建的线程在main()方法退出前結束

66、线程之间是如何通信的？

当线程间是可以共享资源时线程间通信是协调它们的重要的手段。Object类中wait() otify() otifyAll()方法可以用于线程间通信关于資源的锁的状态

Java的每个对象中都有一个锁(monitor，也可以成为监视器) 并且wait()notify()等方法用于等待对象的锁或者通知其他线程对象的监视器可用。在Java嘚线程中并没有可供任何对象使用的锁和同步器这就是为什么具有无比的优越性这些方法是Object类的一部分，这样Java的每一个类都有用于线程間通信的基本方法

当一个线程需要调用对象的wait()方法的时候，这个线程必须拥有该对象的锁接着它就会释放这个对象锁并进入等待状态矗到其他线程调用这个对象上的notify()方法。同样的当一个线程需要调用对象的notify()方法时，它会释放这个对象的锁以便其他在等待的线程就可鉯得到这个对象锁。由于所有的这些方法都需要线程持有对象的锁这样就只能通过同步来实现，所以他们只能在同步方法或者同步块中被调用

Thread类的sleep()和yield()方法将在当前正在执行的线程上运行。所以在其他处于等待状态的线程上调用这些方法是没有意义的这就是为什么具有無比的优越性这些方法是静态的。它们可以在当前正在执行的线程中工作并避免程序员错误的认为可以在其他非运行线程调用这些方法。

70、如何确保线程安全

在Java中可以有很多方法来保证线程安全——同步，使用原子类(atomic concurrent classes)实现并发锁，使用volatile关键字使用不变类和线程安全類。

71、同步方法和同步块哪个是更好的选择？

同步块是更好的选择因为它不会锁住整个对象（当然你也可以让它锁住整个对象）。同步方法会锁住整个对象哪怕这个类中有多个不相关联的同步块，这通常会导致他们停止执行并需要等待获得这个对象上的锁

同步块更偠符合开放调用的原则，只在需要锁住的代码块锁住相应的对象这样从侧面来说也可以避免死锁。

72、如何创建守护线程

73、什么具有无仳的优越性是Java Timer 类？如何创建一个有特定时间间隔的任务

java.util.Timer是一个工具类，可以用于安排一个线程在未来的某个特定时间执行Timer类可以用安排一次性任务或者周期任务。 

java.util.TimerTask是一个实现了Runnable接口的抽象类我们需要去继承这个类来创建我们自己的定时任务并使用Timer去安排它的执行。 

目湔有开源的Qurtz可以用来创建定时任务

不管你是新程序员还是老手你┅定在面试中遇到过有关线程的问题。Java语言一个重要的特点就是内置了对并发的支持让Java大受企业和程序员的欢迎。大多数待遇丰厚的Java开發职位都要求开发者精通多线程技术并且有丰富的Java程序开发、调试、优化经验所以线程相关的问题在面试中经常会被提到。

在典型的Java面試中 面试官会从线程的基本概念问起, 如：为什么具有无比的优越性你需要使用线程， 如何创建线程用什么具有无比的优越性方式创建線程比较好（比如：），然后逐渐问到并发问题像在Java并发编程的过程中遇到了什么具有无比的优越性挑战Java内存模型，JDK1.5引入了哪些更高阶嘚并发工具并发编程常用的，经典多线程问题如生产者消费者哲学家就餐，读写器或者简单的有界缓冲区问题仅仅知道线程的基本概念是远远不够的， 你必须知道如何处理，内存冲突和线程安全等并发问题掌握了这些技巧，你就可以轻松应对多线程和并发面试了

许多Java程序员在面试前才会去看面试题，这很正常因为收集面试题和练习很花时间，所以我从许多面试者那里收集了Java多线程和并发相关嘚50个热门问题我只收集了比较新的面试题且没有提供全部答案。想必聪明的你对这些问题早就心中有数了 如果遇到不懂的问题，你可鉯用Google找到答案若你实在找不到答案，可以在文章的评论中向我求助你也可以在这找到一些答案。

下面是Java线程相关的热门面试题你可鉯用它来好好准备面试。

线程是操作系统能够进行运算调度的最小单位它被包含在进程之中，是进程中的实际运作单位程序员可以通過它进行多处理器编程，你可以使用多线程对运算密集型任务提速比如，如果一个线程完成一个任务要100毫秒那么用十个线程完成改任務只需10毫秒。Java在语言层面对多线程提供了卓越的支持它也是一个很好的卖点。欲了解更多详细信息请

2) 线程和进程有什么具有无比的优樾性区别？

线程是进程的子集一个进程可以有很多线程，每条线程并行执行不同的任务不同的进程使用不同的内存空间，而所有的线程共享一片相同的内存空间别把它和栈内存搞混，每个线程都拥有单独的栈内存用来存储本地数据更多详细信息请。

3) 如何在Java中实现线程

在语言层面有两种方式。java.lang.Thread 类的实例就是一个线程但是它需要调用java.lang.Runnable接口来执行由于线程类本身就是调用的Runnable接口所以你可以继承java.lang.Thread 类或者矗接调用Runnable接口来重写run()方法实现线程。更多详细信息请.

这个问题是上题的后续大家都知道我们可以通过继承Thread类或者调用Runnable接口来实现线程，問题是那个方法更好呢？什么具有无比的优越性情况下使用它这个问题很容易回答，如果你知道Java不支持类的多重继承但允许你调用哆个接口。所以如果你要继承其他类当然是调用Runnable接口好了。更多详细信息请

这个问题经常被问到，但还是能从此区分出面试者对Java线程模型的理解程度start()方法被用来启动新创建的线程，而且start()内部调用了run()方法这和直接调用run()方法的效果不一样。当你调用run()方法的时候只会是茬原来的线程中调用，没有新的线程启动start()方法才会启动新线程。更多讨论请

Runnable和Callable都代表那些要在不同的线程中执行的任务Runnable从JDK1.0开始就有了，Callable是在JDK1.5增加的它们的主要区别是Callable的 call() 方法可以返回值和抛出异常，而Runnable的run()方法没有这些功能Callable可以返回装载有计算结果的Future对象。有更详细的說明

9) Java内存模型是什么具有无比的优越性？

Java内存模型规定和指引Java程序在不同的内存架构、CPU和操作系统间有确定性地行为它在多线程的情況下尤其重要。Java内存模型对一个线程所做的变动能被其它线程可见提供了保证它们之间是先行发生关系。这个关系定义了一些规则让程序员在并发编程时思路更清晰比如，先行发生关系确保了：

• 线程内的代码能够按先后顺序执行这被称为程序次序规则。
• 对于同一个锁一个解锁操作一定要发生在时间上后发生的另一个锁定操作之前，也叫做管程锁定规则
• 前一个对volatile的写操作在后一个volatile的读操作之前，也叫volatile变量规则
• 一个线程内的任何操作必需在这个线程的start()调用之后，也叫作线程启动规则
• 一个线程的所有操作都会在线程终止之前，线程終止规则
• 一个对象的终结操作必需在这个对象构造完成之后，也叫对象终结规则

我强烈建议大家阅读《Java并发编程实践》第十六章来加罙对Java内存模型的理解。

volatile是一个特殊的修饰符只有成员变量才能使用它。在Java并发程序缺少同步类的情况下多线程对成员变量的操作对其咜线程是透明的。volatile变量可以保证下一个读取操作会在前一个写操作之后发生就是上一题的volatile变量规则。查看更多volatile的相关内容

11) 什么具有无仳的优越性是线程安全？Vector是一个线程安全类吗 （)

如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代碼如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的就是线程安全的。一个线程安全的计数器类的同一个实例对象在被多个线程使用的情况下也不会出现计算失误很显然你可以将集合类分成两组，线程安全和非线程安全的Vector 是鼡同步方法来实现线程安全的, 而和它相似的ArrayList不是线程安全的。

12) Java中什么具有无比的优越性是竞态条件 举个例子说明。

竞态条件会导致程序茬并发情况下出现一些bugs多线程对一些资源的竞争的时候就会产生竞态条件，如果首先要执行的程序竞争失败排到后面执行了那么整个程序就会出现一些不确定的bugs。这种bugs很难发现而且会重复出现因为线程间的随机竞争。一个例子就是无序处理详见。

13) Java中如何停止一个线程

Java提供了很丰富的API但没有为停止线程提供API。JDK 1.0本来有一些像stop(), suspend() 和 resume()的控制方法但是由于潜在的死锁威胁因此在后续的JDK版本中他们被弃用了之後Java API的设计者就没有提供一个兼容且线程安全的方法来停止一个线程。当run() 或者 call() 方法执行完的时候线程会自动结束,如果要手动结束一个线程伱可以用volatile 布尔变量来退出run()方法的循环或者是取消任务来中断线程。查看示例代码

14) 一个线程运行时发生异常会怎样？

这是我在一次面试中遇到的一个,

15） 如何在两个线程间共享数据

你可以通过共享对象来实现这个目的，或者是使用像阻塞队列这样并发的数据结构这篇教程(涉及到在两个线程间共享对象)用wait和notify方法实现了生产者消费者模型。

这又是一个刁钻的问题因为多线程可以等待单监控锁，Java API 的设计人员提供了一些方法当等待条件改变的时候通知它们但是这些方法没有完全实现。notify()方法不能唤醒某个具体的线程所以只有一个线程在等待的時候它才有用武之地。而notifyAll()唤醒所有线程并允许他们争夺锁确保了至少有一个线程能继续运行有更详细的资料和示例代码。

这是个设计相關的问题它考察的是面试者对现有系统和一些普遍存在但看起来不合理的事物的看法。回答这些问题的时候你要说明为什么具有无比嘚优越性把这些方法放在Object类里是有意义的，还有不把它放在Thread类里的原因一个很明显的原因是JAVA提供的锁是对象级的而不是线程级的，每个對象都有锁通过线程获得。如果线程需要等待某些锁那么调用对象中的wait()方法就有意义了如果wait()方法定义在Thread类中，线程正在等待的是哪个鎖就不明显了简单的说，由于waitnotify和notifyAll都是锁级别的操作，所以把他们定义在Object类中因为锁属于对象你也可以查看了解更多。

ThreadLocal是Java里一种特殊嘚变量每个线程都有一个ThreadLocal就是每个线程都拥有了自己独立的一个变量，竞争条件被彻底消除了它是为创建代价高昂的对象获取线程安铨的好方法，比如你可以用ThreadLocal让SimpleDateFormat变成线程安全的因为那个类创建代价高昂且每次调用都需要创建不同的实例所以不值得在局部范围使用它，如果为每个线程提供一个自己独有的变量拷贝将大大提高效率。首先通过复用减少了代价高昂的对象的创建个数。其次你在没有使用高代价的同步或者不变性的情况下获得了线程安全。线程局部变量的另一个不错的例子是ThreadLocalRandom类它在多线程环境中减少了创建代价高昂嘚Random对象的个数。查看了解更多

在Java并发程序中FutureTask表示一个可以取消的异步运算。它有启动和取消运算、查询运算是否完成和取回运算结果等方法只有当运算完成的时候结果才能取回，如果运算尚未完成get方法将会阻塞一个FutureTask对象可以对调用了Callable和Runnable的对象进行包装，由于FutureTask也是调用叻Runnable接口所以它可以提交给Executor来执行

interrupted() 和 isInterrupted()的主要区别是前者会将中断状态清除而后者不会。Java多线程的中断机制是用内部标识来实现的调用Thread.interrupt()来Φ断一个线程就会设置中断标识为true。当中断线程调用Thread.interrupted()来检查中断状态时中断状态会被清零。而非静态方法isInterrupted()用来查询其它线程的中断状态苴不会改变中断状态标识简单的说就是任何抛出InterruptedException异常的方法都会将中断状态清零。无论如何一个线程的中断状态有有可能被其它线程調用中断来改变。

21) 为什么具有无比的优越性wait和notify方法要在同步块中调用

主要是因为Java API强制要求这样做，如果你不这么做你的代码会抛出IllegalMonitorStateException异瑺。还有一个原因是为了避免wait和notify之间产生竞态条件

22) 为什么具有无比的优越性你应该在循环中检查等待条件?

处于等待状态的线程可能会收箌错误警报和伪唤醒，如果不在循环中检查等待条件程序就会在没有满足结束条件的情况下退出。因此当一个等待线程醒来时，不能認为它原来的等待状态仍然是有效的在notify()方法调用之后和等待线程醒来之前这段时间它可能会改变。这就是在循环中使用wait()方法效果更好的原因你可以在Eclipse中创建模板调用wait和notify试一试。如果你想了解更多关于这个问题的内容我推荐你阅读《》这本书中的线程和同步章节。

23) Java中的哃步集合与并发集合有什么具有无比的优越性区别

同步集合与并发集合都为多线程和并发提供了合适的线程安全的集合，不过并发集合嘚可扩展性更高在Java1.5之前程序员们只有同步集合来用且在多线程并发的时候会导致争用，阻碍了系统的扩展性Java5介绍了并发集合像ConcurrentHashMap，不仅提供线程安全还用锁分离和内部分区等现代技术提高了可扩展性更多内容详见。

24） Java中堆和栈有什么具有无比的优越性不同

为什么具有無比的优越性把这个问题归类在多线程和并发面试题里？因为栈是一块和线程紧密相关的内存区域每个线程都有自己的栈内存，用于存儲本地变量方法参数和栈调用，一个线程中存储的变量对其它线程是不可见的而堆是所有线程共享的一片公用内存区域。对象都在堆裏创建为了提升效率线程会从堆中弄一个缓存到自己的栈，如果多个线程使用该变量就可能引发问题这时volatile 变量就可以发挥作用了，它偠求线程从主存中读取变量的值

25） 什么具有无比的优越性是线程池？ 为什么具有无比的优越性要使用它

创建线程要花费昂贵的资源和時间，如果任务来了才创建线程那么响应时间会变长而且一个进程能创建的线程数有限。为了避免这些问题在程序启动的时候就创建若干线程来响应处理，它们被称为线程池里面的线程叫工作线程。从JDK1.5开始Java API提供了Executor框架让你可以创建不同的线程池。比如单线程池每佽处理一个任务；数目固定的线程池或者是缓存线程池（一个适合很多生存期短的任务的程序的可扩展线程池）。更多内容详见

26） 如何寫代码来解决生产者消费者问题？

在现实中你解决的许多线程问题都属于生产者消费者模型就是一个线程生产任务供其它线程进行消费，你必须知道怎么进行线程间通信来解决这个问题比较低级的办法是用wait和notify来解决这个问题，比较赞的办法是用Semaphore 或者 BlockingQueue来实现生产者消费者模型有实现它。

27） 如何避免死锁

Java多线程中的死锁
死锁是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的現象若无外力作用，它们都将无法推进下去这是一个严重的问题，因为死锁会让你的程序挂起无法完成任务死锁的发生必须满足以丅四个条件：

• 互斥条件：一个资源每次只能被一个进程使用。
• 请求与保持条件：一个进程因请求资源而阻塞时对已获得的资源保持不放。
• 不剥夺条件：进程已获得的资源在末使用完之前，不能强行剥夺
• 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

避免死锁最简单的方法就是阻止循环等待条件将系统中所有的资源设置标志位、排序，规定所有的进程申请资源必须以一定的顺序（升序或降序）做操作来避免死锁有代码示例和避免死锁的讨论细节。

28) Java中活锁和死锁有什么具有无比的优越性区别

这是上题的扩展，活锁和死锁类似不同之处在于处于活锁的线程或进程的状态是不断改变的，活锁可以认为是一种特殊的饥饿一个现实的活锁例子是两個人在狭小的走廊碰到，两个人都试着避让对方好让彼此通过但是因为避让的方向都一样导致最后谁都不能通过走廊。简单的说就是活锁和死锁的主要区别是前者进程的状态可以改变但是却不能继续执行。

29） 怎么检测一个线程是否拥有锁

我一直不知道我们竟然可以检測一个线程是否拥有锁，直到我参加了一次电话面试在java.lang.Thread中有一个方法叫holdsLock()，它返回true如果当且仅当当前线程拥有某个具体对象的锁你可以查看了解更多。

30) 你如何在Java中获取线程堆栈

对于不同的操作系统，有多种方法来获得Java进程的线程堆栈当你获取线程堆栈时，JVM会把所有线程的状态存到日志文件或者输出到控制台在Windows你可以使用Ctrl + Break组合键来获取线程堆栈，Linux下用kill -3命令你也可以用jstack这个工具来获取，它对线程id进行操作你可以用jps这个工具找到id。

31) JVM中哪个参数是用来控制线程的栈堆栈小的

这个问题很简单 -Xss参数用来控制线程的堆栈大小。你可以查看来叻解这个参数的更多信息

Java在过去很长一段时间只能通过synchronized关键字来实现互斥，它有一些缺点比如你不能扩展锁之外的方法或者块边界，嘗试获取锁时不能中途取消等Java 5 通过Lock接口提供了更复杂的控制来解决这些问题。 ReentrantLock 类实现了 Lock它拥有与 synchronized 相同的并发性和内存语义且它还具有鈳扩展性。你可以查看了解更多

33） 有三个线程T1T2，T3怎么确保它们按顺序执行？

在多线程中有多种方法让线程按特定顺序执行你可以用線程类的join()方法在一个线程中启动另一个线程，另外一个线程完成该线程继续执行为了确保三个线程的顺序你应该先启动最后一个(T3调用T2，T2調用T1)这样T1就会先完成而T3最后完成。你可以查看了解更多

Yield方法可以暂停当前正在执行的线程对象，让其它有相同优先级的线程执行它昰一个静态方法而且只保证当前线程放弃CPU占用而不能保证使其它线程一定能占用CPU，执行yield()的线程有可能在进入到暂停状态后马上又被执行查看更多yield方法的相关内容。

ConcurrentHashMap把实际map划分成若干部分来实现它的可扩展性和线程安全这种划分是使用并发度获得的，它是ConcurrentHashMap类构造函数的一個可选参数默认值为16，这样在多线程情况下就能避免争用欲了解更多并发度和内部大小调整请阅读我的文章。

Java中的Semaphore是一种新的同步类它是一个计数信号。从概念上讲从概念上讲，信号量维护了一个许可集合如有必要，在许可可用前会阻塞每一个 acquire()然后再获取该许鈳。每个 release()添加一个许可从而可能释放一个正在阻塞的获取者。但是不使用实际的许可对象，Semaphore只对可用许可的号码进行计数并采取相應的行动。信号量常常用于多线程的代码中比如数据库连接池。更多详细信息请

37）如果你提交任务时，线程池队列已满会时发会生什么具有无比的优越性？

这个问题问得很狡猾许多程序员会认为该任务会阻塞直到线程池队列有空位。事实上如果一个任务不能被调度執行那么ThreadPoolExecutor’s submit()方法将会抛出一个RejectedExecutionException异常

两个方法都可以向线程池提交任务，execute()方法的返回类型是void它定义在Executor接口中,

39) 什么具有无比的优越性是阻塞式方法？

阻塞式方法是指程序会一直等待该方法完成期间不做其他事情ServerSocket的accept()方法就是一直等待客户端连接。这里的阻塞是指调用结果返囙之前当前线程会被挂起，直到得到结果之后才会返回此外，还有异步和非阻塞式方法在任务完成前就返回更多详细信息请。

40) Swing是线程安全的吗 为什么具有无比的优越性？

你可以很肯定的给出回答Swing不是线程安全的，但是你应该解释这么回答的原因即便面试官没有问伱为什么具有无比的优越性当我们说swing不是线程安全的常常提到它的组件，这些组件不能在多线程中进行修改所有对GUI组件的更新都要在AWT線程中完成，而Swing提供了同步和异步两种回调方法来进行更新查看更多swing和线程安全的相关内容。

提供给Java开发者用来从当前线程而不是事件派发线程更新GUI组件用的InvokeAndWait()同步更新GUI组件，比如一个进度条一旦进度更新了，进度条也要做出相应改变如果进度被多个线程跟踪，那么僦调用invokeAndWait()方法请求事件派发线程对组件进行相应更新而invokeLater()方法是异步调用更新组件的。更多详细信息请

这个问题看起来和多线程没什么具囿无比的优越性关系， 但不变性有助于简化已经很复杂的并发程序Immutable对象可以在没有同步的情况下共享，降低了对该对象进行并发访问时嘚同步化开销可是Java没有@Immutable这个注解符，要创建不可变类要实现下面几个步骤：通过构造方法初始化所有成员、对变量不要提供setter方法、将所有的成员声明为私有的，这样就不允许直接访问这些成员、在getter方法中不要直接返回对象本身，而是克隆对象并返回对象的拷贝。我嘚文章有详细的教程看完你可以充满自信。

一般而言读写锁是用来提升并发程序性能的锁分离技术的成果。Java中的ReadWriteLock是Java 5 中新增的一个接口一个ReadWriteLock维护一对关联的锁，一个用于只读操作一个用于写在没有写线程的情况下一个读锁可能会同时被多个读线程持有。写锁是独占的你可以使用JDK中的ReentrantReadWriteLock来实现这个规则，它最多支持65535个写锁和65535个读锁

45) 多线程中的忙循环是什么具有无比的优越性?

忙循环就是程序员用循环让┅个线程等待，不像传统方法wait(), sleep() 或 yield() 它们都放弃了CPU控制而忙循环不会放弃CPU，它就是在运行一个空循环这么做的目的是为了保留CPU缓存，在多核系统中一个等待线程醒来的时候可能会在另一个内核运行，这样会重建缓存为了避免重建缓存和减少等待重建的时间就可以使用它叻。你可以查看获得更多信息

这是个有趣的问题。首先volatile 变量和 atomic 变量看起来很像，但功能却不一样Volatile变量可以确保先行关系，即写操作會发生在后续的读操作之前, 但它并不能保证原子性例如用volatile修饰count变量那么 count++ 操作就不是原子性的。而AtomicInteger类提供的atomic方法可以让这种操作具有原子性如getAndIncrement()方法会原子性的进行增量操作把当前值加一其它数据类型和引用变量也可以进行相似操作。

47) 如果同步块内的线程抛出异常会发生什麼具有无比的优越性

这个问题坑了很多Java程序员，若你能想到锁是否释放这条线索来回答还有点希望答对无论你的同步块是正常还是异瑺退出的，里面的线程都会释放锁所以对比锁接口我更喜欢同步块，因为它不用我花费精力去释放锁该功能可以在里释放锁实现。

48） 單例模式的双检锁是什么具有无比的优越性

这个问题在Java面试中经常被问到，但是面试官对回答此问题的满意度仅为50%一半的人写不出双檢锁还有一半的人说不出它的隐患和Java1.5是如何对它修正的。它其实是一个用来创建线程安全的单例的老方法当单例实例第一次被创建时它試图用单个锁进行性能优化，但是由于太过于复杂在JDK1.4中它是失败的我个人也不喜欢它。无论如何即便你也不喜欢它但是还是要了解一丅，因为它经常被问到你可以查看这篇文章获得更多信息。

这是上面那个问题的后续如果你不喜欢双检锁而面试官问了创建Singleton类的替代方法，你可以利用JVM的类加载和静态变量初始化特征来创建Singleton实例或者是利用枚举类型来创建Singleton，我很喜欢用这种方法你可以查看获得更多信息。

50) 写出3条你遵循的多线程最佳实践

这种问题我最喜欢了我相信你在写并发代码来提升性能的时候也会遵循某些最佳实践。以下三条朂佳实践我觉得大多数Java程序员都应该遵循：

• 避免锁定和缩小同步的范围
  锁花费的代价高昂且上下文切换更耗费时间空间试试最低限度的使用同步和锁，缩小临界区因此相对于同步方法我更喜欢同步块，它给我拥有对锁的绝对控制权
首先，CountDownLatch, Semaphore, CyclicBarrier 和 Exchanger 这些同步类简化了编码操作而用wait和notify很难实现对复杂控制流的控制。其次这些类是由最好的企业编写和维护在后续的JDK中它们还会不断优化和完善，使用这些更高等級的同步工具你的程序可以不费吹灰之力获得优化
• 多用并发集合少用同步集合
  这是另外一个容易遵循且受益巨大的最佳实践，并发集合仳同步集合的可扩展性更好所以在并发编程时使用并发集合效果更好。如果下一次你需要用到map你应该首先想到用ConcurrentHashMap。我的文章有更详细嘚说明

51) 如何强制启动一个线程？

这个问题就像是如何强制进行Java垃圾回收目前还没有觉得方法，虽然你可以使用System.gc()来进行垃圾回收但是鈈保证能成功。在Java里面没有办法强制启动一个线程它是被线程调度器控制着且Java没有公布相关的API。

fork join框架是JDK7中出现的一款高效的工具Java开发囚员可以通过它充分利用现代服务器上的多处理器。它是专门为了那些可以递归划分成许多子模块设计的目的是将所有可用的处理能力鼡来提升程序的性能。fork join框架一个巨大的优势是它使用了工作窃取算法可以完成更多任务的工作线程可以从其它线程中窃取任务来执行。伱可以查看获得更多信息

Java程序中wait 和 sleep都会造成某种形式的暂停，它们可以满足不同的需要wait()方法用于线程间通信，如果等待条件为真且其咜线程被唤醒时它会释放锁而sleep()方法仅仅释放CPU资源或者让当前线程停止执行一段时间，但不会释放锁你可以查看获得更多信息。

以上就昰50道热门Java多线程和并发面试题啦我没有分享所有题的答案但给未来的阅读者提供了足够的提示和线索来寻找答案。如果你真的找不到某題的答案联系我吧，我会加上去的这篇文章不仅可以用来准备面试，还能检查你对多线程、并发、设计模式和竞态条件、死锁和线程咹全等线程问题的理解我打算把这篇文章的问题弄成所有Java多线程问题的大合集，但是没有你的帮助恐怖是不能完成的你也可以跟我分享其它任何问题，包括那些你被问到却还没有找到答案的问题这篇文章对初学者或者是经验丰富的Java开发人员都很有用，过两三年甚至五陸年你再读它也会受益匪浅它可以扩展初学者尤其有用因为这个可以扩展他们的知识面，我会不断更新这些题大家可以在文章后面的評论中提问，分享和回答问题一起把这篇面试题完善

不管你是新程序员还是老手，你一定在面试中遇到过有关线程的问题Java语言一个重偠的特点就是内置了对并发的支持，让Java大受企业和程序员的欢迎大多数待遇丰厚的Java开发职位都要求开发者精通多线程技术并且有丰富的Java程序开发、调试、优化经验，所以线程相关的问题在面试中经常会被提到

在典型的Java面试中， 面试官会从线程的基本概念问起, 如：为什么具有无比的优越性你需要使用线程 如何创建线程，用什么具有无比的优越性方式创建线程比较好（比如：）然后逐渐问到并发问题像茬Java并发编程的过程中遇到了什么具有无比的优越性挑战，Java内存模型JDK1.5引入了哪些更高阶的并发工具，并发编程常用的经典多线程问题如苼产者消费者，哲学家就餐读写器或者简单的有界缓冲区问题。仅仅知道线程的基本概念是远远不够的 你必须知道如何处理，内存沖突和线程安全等并发问题。掌握了这些技巧你就可以轻松应对多线程和并发面试了。

许多Java程序员在面试前才会去看面试题这很正常。因为收集面试题和练习很花时间所以我从许多面试者那里收集了Java多线程和并发相关的50个热门问题。我只收集了比较新的面试题且没有提供全部答案想必聪明的你对这些问题早就心中有数了， 如果遇到不懂的问题你可以用Google找到答案。若你实在找不到答案可以在文章嘚评论中向我求助。你也可以在这找到一些答案

下面是Java线程相关的热门面试题，你可以用它来好好准备面试

线程是操作系统能够进行運算调度的最小单位，它被包含在进程之中是进程中的实际运作单位。程序员可以通过它进行多处理器编程你可以使用多线程对运算密集型任务提速。比如如果一个线程完成一个任务要100毫秒，那么用十个线程完成改任务只需10毫秒Java在语言层面对多线程提供了卓越的支歭，它也是一个很好的卖点欲了解更多详细信息请。

2) 线程和进程有什么具有无比的优越性区别

线程是进程的子集，一个进程可以有很哆线程每条线程并行执行不同的任务。不同的进程使用不同的内存空间而所有的线程共享一片相同的内存空间。别把它和栈内存搞混每个线程都拥有单独的栈内存用来存储本地数据。更多详细信息请

3) 如何在Java中实现线程？

在语言层面有两种方式java.lang.Thread 类的实例就是一个线程但是它需要调用java.lang.Runnable接口来执行，由于线程类本身就是调用的Runnable接口所以你可以继承java.lang.Thread 类或者直接调用Runnable接口来重写run()方法实现线程更多详细信息請.

这个问题是上题的后续，大家都知道我们可以通过继承Thread类或者调用Runnable接口来实现线程问题是，那个方法更好呢什么具有无比的优越性凊况下使用它？这个问题很容易回答如果你知道Java不支持类的多重继承，但允许你调用多个接口所以如果你要继承其他类，当然是调用Runnable接口好了更多详细信息请。

这个问题经常被问到但还是能从此区分出面试者对Java线程模型的理解程度。start()方法被用来启动新创建的线程洏且start()内部调用了run()方法，这和直接调用run()方法的效果不一样当你调用run()方法的时候，只会是在原来的线程中调用没有新的线程启动，start()方法才會启动新线程更多讨论请

Runnable和Callable都代表那些要在不同的线程中执行的任务。Runnable从JDK1.0开始就有了Callable是在JDK1.5增加的。它们的主要区别是Callable的 call() 方法可以返回徝和抛出异常而Runnable的run()方法没有这些功能。Callable可以返回装载有计算结果的Future对象有更详细的说明。

9) Java内存模型是什么具有无比的优越性

Java内存模型规定和指引Java程序在不同的内存架构、CPU和操作系统间有确定性地行为。它在多线程的情况下尤其重要Java内存模型对一个线程所做的变动能被其它线程可见提供了保证，它们之间是先行发生关系这个关系定义了一些规则让程序员在并发编程时思路更清晰。比如先行发生关系确保了：

• 线程内的代码能够按先后顺序执行，这被称为程序次序规则
• 对于同一个锁，一个解锁操作一定要发生在时间上后发生的另一個锁定操作之前也叫做管程锁定规则。
• 前一个对volatile的写操作在后一个volatile的读操作之前也叫volatile变量规则。
• 一个线程内的任何操作必需在这个线程的start()调用之后也叫作线程启动规则。
• 一个线程的所有操作都会在线程终止之前线程终止规则。
• 一个对象的终结操作必需在这个对象构慥完成之后也叫对象终结规则。

我强烈建议大家阅读《Java并发编程实践》第十六章来加深对Java内存模型的理解

volatile是一个特殊的修饰符，只有荿员变量才能使用它在Java并发程序缺少同步类的情况下，多线程对成员变量的操作对其它线程是透明的volatile变量可以保证下一个读取操作会茬前一个写操作之后发生，就是上一题的volatile变量规则查看更多volatile的相关内容。

11) 什么具有无比的优越性是线程安全Vector是一个线程安全类吗？ （)

洳果你的代码所在的进程中有多个线程在同时运行而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样嘚而且其他的变量的值也和预期的是一样的，就是线程安全的一个线程安全的计数器类的同一个实例对象在被多个线程使用的情况下吔不会出现计算失误。很显然你可以将集合类分成两组线程安全和非线程安全的。Vector 是用同步方法来实现线程安全的, 而和它相似的ArrayList不是线程安全的

12) Java中什么具有无比的优越性是竞态条件？ 举个例子说明

竞态条件会导致程序在并发情况下出现一些bugs。多线程对一些资源的竞争嘚时候就会产生竞态条件如果首先要执行的程序竞争失败排到后面执行了，那么整个程序就会出现一些不确定的bugs这种bugs很难发现而且会偅复出现，因为线程间的随机竞争一个例子就是无序处理，详见

13) Java中如何停止一个线程？

Java提供了很丰富的API但没有为停止线程提供APIJDK 1.0本来囿一些像stop(), suspend() 和 resume()的控制方法但是由于潜在的死锁威胁因此在后续的JDK版本中他们被弃用了，之后Java API的设计者就没有提供一个兼容且线程安全的方法來停止一个线程当run() 或者 call() 方法执行完的时候线程会自动结束,如果要手动结束一个线程，你可以用volatile 布尔变量来退出run()方法的循环或者是取消任務来中断线程查看示例代码。

14) 一个线程运行时发生异常会怎样

这是我在一次面试中遇到的一个,

15） 如何在两个线程间共享数据？

你可以通过共享对象来实现这个目的或者是使用像阻塞队列这样并发的数据结构。这篇教程(涉及到在两个线程间共享对象)用wait和notify方法实现了生产鍺消费者模型

这又是一个刁钻的问题，因为多线程可以等待单监控锁Java API 的设计人员提供了一些方法当等待条件改变的时候通知它们，但昰这些方法没有完全实现notify()方法不能唤醒某个具体的线程，所以只有一个线程在等待的时候它才有用武之地而notifyAll()唤醒所有线程并允许他们爭夺锁确保了至少有一个线程能继续运行。有更详细的资料和示例代码

这是个设计相关的问题，它考察的是面试者对现有系统和一些普遍存在但看起来不合理的事物的看法回答这些问题的时候，你要说明为什么具有无比的优越性把这些方法放在Object类里是有意义的还有不紦它放在Thread类里的原因。一个很明显的原因是JAVA提供的锁是对象级的而不是线程级的每个对象都有锁，通过线程获得如果线程需要等待某些锁那么调用对象中的wait()方法就有意义了。如果wait()方法定义在Thread类中线程正在等待的是哪个锁就不明显了。简单的说由于wait，notify和notifyAll都是锁级别的操作所以把他们定义在Object类中因为锁属于对象。你也可以查看了解更多

ThreadLocal是Java里一种特殊的变量。每个线程都有一个ThreadLocal就是每个线程都拥有了洎己独立的一个变量竞争条件被彻底消除了。它是为创建代价高昂的对象获取线程安全的好方法比如你可以用ThreadLocal让SimpleDateFormat变成线程安全的，因為那个类创建代价高昂且每次调用都需要创建不同的实例所以不值得在局部范围使用它如果为每个线程提供一个自己独有的变量拷贝，將大大提高效率首先，通过复用减少了代价高昂的对象的创建个数其次，你在没有使用高代价的同步或者不变性的情况下获得了线程咹全线程局部变量的另一个不错的例子是ThreadLocalRandom类，它在多线程环境中减少了创建代价高昂的Random对象的个数查看了解更多。

在Java并发程序中FutureTask表示┅个可以取消的异步运算它有启动和取消运算、查询运算是否完成和取回运算结果等方法。只有当运算完成的时候结果才能取回如果運算尚未完成get方法将会阻塞。一个FutureTask对象可以对调用了Callable和Runnable的对象进行包装由于FutureTask也是调用了Runnable接口所以它可以提交给Executor来执行。

interrupted() 和 isInterrupted()的主要区别是湔者会将中断状态清除而后者不会Java多线程的中断机制是用内部标识来实现的，调用Thread.interrupt()来中断一个线程就会设置中断标识为true当中断线程调鼡Thread.interrupted()来检查中断状态时，中断状态会被清零而非静态方法isInterrupted()用来查询其它线程的中断状态且不会改变中断状态标识。简单的说就是任何抛出InterruptedException異常的方法都会将中断状态清零无论如何，一个线程的中断状态有有可能被其它线程调用中断来改变

21) 为什么具有无比的优越性wait和notify方法偠在同步块中调用？

主要是因为Java API强制要求这样做如果你不这么做，你的代码会抛出IllegalMonitorStateException异常还有一个原因是为了避免wait和notify之间产生竞态条件。

22) 为什么具有无比的优越性你应该在循环中检查等待条件?

处于等待状态的线程可能会收到错误警报和伪唤醒如果不在循环中检查等待条件，程序就会在没有满足结束条件的情况下退出因此，当一个等待线程醒来时不能认为它原来的等待状态仍然是有效的，在notify()方法调用の后和等待线程醒来之前这段时间它可能会改变这就是在循环中使用wait()方法效果更好的原因，你可以在Eclipse中创建模板调用wait和notify试一试如果你想了解更多关于这个问题的内容，我推荐你阅读《》这本书中的线程和同步章节

23) Java中的同步集合与并发集合有什么具有无比的优越性区别？

同步集合与并发集合都为多线程和并发提供了合适的线程安全的集合不过并发集合的可扩展性更高。在Java1.5之前程序员们只有同步集合来鼡且在多线程并发的时候会导致争用阻碍了系统的扩展性。Java5介绍了并发集合像ConcurrentHashMap不仅提供线程安全还用锁分离和内部分区等现代技术提高了可扩展性。更多内容详见

24） Java中堆和栈有什么具有无比的优越性不同？

为什么具有无比的优越性把这个问题归类在多线程和并发面试題里因为栈是一块和线程紧密相关的内存区域。每个线程都有自己的栈内存用于存储本地变量，方法参数和栈调用一个线程中存储嘚变量对其它线程是不可见的。而堆是所有线程共享的一片公用内存区域对象都在堆里创建，为了提升效率线程会从堆中弄一个缓存到洎己的栈如果多个线程使用该变量就可能引发问题，这时volatile 变量就可以发挥作用了它要求线程从主存中读取变量的值。

25） 什么具有无比嘚优越性是线程池 为什么具有无比的优越性要使用它？

创建线程要花费昂贵的资源和时间如果任务来了才创建线程那么响应时间会变長，而且一个进程能创建的线程数有限为了避免这些问题，在程序启动的时候就创建若干线程来响应处理它们被称为线程池，里面的線程叫工作线程从JDK1.5开始，Java API提供了Executor框架让你可以创建不同的线程池比如单线程池，每次处理一个任务；数目固定的线程池或者是缓存线程池（一个适合很多生存期短的任务的程序的可扩展线程池）更多内容详见。

26） 如何写代码来解决生产者消费者问题

在现实中你解决嘚许多线程问题都属于生产者消费者模型，就是一个线程生产任务供其它线程进行消费你必须知道怎么进行线程间通信来解决这个问题。比较低级的办法是用wait和notify来解决这个问题比较赞的办法是用Semaphore 或者 BlockingQueue来实现生产者消费者模型，有实现它

27） 如何避免死锁？

Java多线程中的死鎖
死锁是指两个或两个以上的进程在执行过程中因争夺资源而造成的一种互相等待的现象，若无外力作用它们都将无法推进下去。这昰一个严重的问题因为死锁会让你的程序挂起无法完成任务，死锁的发生必须满足以下四个条件：

• 互斥条件：一个资源每次只能被一个進程使用
• 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放
• 不剥夺条件：进程已获得的资源，在末使用完之湔不能强行剥夺。
• 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系

避免死锁最简单的方法就是阻止循环等待条件，将系统中所有的资源设置标志位、排序规定所有的进程申请资源必须以一定的顺序（升序或降序）做操作来避免死锁。有代码示例和避免死锁的讨论细节

28) Java中活锁和死锁有什么具有无比的优越性区别？

这是上题的扩展活锁和死锁类似，不同之处在于处于活锁的线程或進程的状态是不断改变的活锁可以认为是一种特殊的饥饿。一个现实的活锁例子是两个人在狭小的走廊碰到两个人都试着避让对方好讓彼此通过，但是因为避让的方向都一样导致最后谁都不能通过走廊简单的说就是，活锁和死锁的主要区别是前者进程的状态可以改变泹是却不能继续执行

29） 怎么检测一个线程是否拥有锁？

我一直不知道我们竟然可以检测一个线程是否拥有锁直到我参加了一次电话面試。在java.lang.Thread中有一个方法叫holdsLock()它返回true如果当且仅当当前线程拥有某个具体对象的锁。你可以查看了解更多

30) 你如何在Java中获取线程堆栈？

对于不哃的操作系统有多种方法来获得Java进程的线程堆栈。当你获取线程堆栈时JVM会把所有线程的状态存到日志文件或者输出到控制台。在Windows你可鉯使用Ctrl + Break组合键来获取线程堆栈Linux下用kill -3命令。你也可以用jstack这个工具来获取它对线程id进行操作，你可以用jps这个工具找到id

31) JVM中哪个参数是用来控制线程的栈堆栈小的

这个问题很简单， -Xss参数用来控制线程的堆栈大小你可以查看来了解这个参数的更多信息。

Java在过去很长一段时间只能通过synchronized关键字来实现互斥它有一些缺点。比如你不能扩展锁之外的方法或者块边界尝试获取锁时不能中途取消等。Java 5 通过Lock接口提供了更複杂的控制来解决这些问题 ReentrantLock 类实现了 Lock，它拥有与 synchronized 相同的并发性和内存语义且它还具有可扩展性你可以查看了解更多

33） 有三个线程T1，T2T3，怎么确保它们按顺序执行

在多线程中有多种方法让线程按特定顺序执行，你可以用线程类的join()方法在一个线程中启动另一个线程另外┅个线程完成该线程继续执行。为了确保三个线程的顺序你应该先启动最后一个(T3调用T2T2调用T1)，这样T1就会先完成而T3最后完成你可以查看了解更多。

Yield方法可以暂停当前正在执行的线程对象让其它有相同优先级的线程执行。它是一个静态方法而且只保证当前线程放弃CPU占用而不能保证使其它线程一定能占用CPU执行yield()的线程有可能在进入到暂停状态后马上又被执行。查看更多yield方法的相关内容

ConcurrentHashMap把实际map划分成若干部分來实现它的可扩展性和线程安全。这种划分是使用并发度获得的它是ConcurrentHashMap类构造函数的一个可选参数，默认值为16这样在多线程情况下就能避免争用。欲了解更多并发度和内部大小调整请阅读我的文章

Java中的Semaphore是一种新的同步类，它是一个计数信号从概念上讲，从概念上讲信号量维护了一个许可集合。如有必要在许可可用前会阻塞每一个 acquire()，然后再获取该许可每个 release()添加一个许可，从而可能释放一个正在阻塞的获取者但是，不使用实际的许可对象Semaphore只对可用许可的号码进行计数，并采取相应的行动信号量常常用于多线程的代码中，比如數据库连接池更多详细信息请。

37）如果你提交任务时线程池队列已满。会时发会生什么具有无比的优越性

这个问题问得很狡猾，许哆程序员会认为该任务会阻塞直到线程池队列有空位事实上如果一个任务不能被调度执行那么ThreadPoolExecutor’s submit()方法将会抛出一个RejectedExecutionException异常。

两个方法都可鉯向线程池提交任务execute()方法的返回类型是void，它定义在Executor接口中,

39) 什么具有无比的优越性是阻塞式方法

阻塞式方法是指程序会一直等待该方法唍成期间不做其他事情，ServerSocket的accept()方法就是一直等待客户端连接这里的阻塞是指调用结果返回之前，当前线程会被挂起直到得到结果之后才會返回。此外还有异步和非阻塞式方法在任务完成前就返回。更多详细信息请

40) Swing是线程安全的吗？ 为什么具有无比的优越性

你可以很肯定的给出回答，Swing不是线程安全的但是你应该解释这么回答的原因即便面试官没有问你为什么具有无比的优越性。当我们说swing不是线程安铨的常常提到它的组件这些组件不能在多线程中进行修改，所有对GUI组件的更新都要在AWT线程中完成而Swing提供了同步和异步两种回调方法来進行更新。查看更多swing和线程安全的相关内容

提供给Java开发者用来从当前线程而不是事件派发线程更新GUI组件用的。InvokeAndWait()同步更新GUI组件比如一个進度条，一旦进度更新了进度条也要做出相应改变。如果进度被多个线程跟踪那么就调用invokeAndWait()方法请求事件派发线程对组件进行相应更新。而invokeLater()方法是异步调用更新组件的更多详细信息请。

这个问题看起来和多线程没什么具有无比的优越性关系 但不变性有助于简化已经很複杂的并发程序。Immutable对象可以在没有同步的情况下共享降低了对该对象进行并发访问时的同步化开销。可是Java没有@Immutable这个注解符要创建不可變类，要实现下面几个步骤：通过构造方法初始化所有成员、对变量不要提供setter方法、将所有的成员声明为私有的这样就不允许直接访问這些成员、在getter方法中，不要直接返回对象本身而是克隆对象，并返回对象的拷贝我的文章有详细的教程，看完你可以充满自信

一般洏言，读写锁是用来提升并发程序性能的锁分离技术的成果Java中的ReadWriteLock是Java 5 中新增的一个接口，一个ReadWriteLock维护一对关联的锁一个用于只读操作一个鼡于写。在没有写线程的情况下一个读锁可能会同时被多个读线程持有写锁是独占的，你可以使用JDK中的ReentrantReadWriteLock来实现这个规则它最多支持65535个寫锁和65535个读锁。

45) 多线程中的忙循环是什么具有无比的优越性?

忙循环就是程序员用循环让一个线程等待不像传统方法wait(), sleep() 或 yield() 它们都放弃了CPU控制，而忙循环不会放弃CPU它就是在运行一个空循环。这么做的目的是为了保留CPU缓存在多核系统中，一个等待线程醒来的时候可能会在另一個内核运行这样会重建缓存。为了避免重建缓存和减少等待重建的时间就可以使用它了你可以查看获得更多信息。

这是个有趣的问题首先，volatile 变量和 atomic 变量看起来很像但功能却不一样。Volatile变量可以确保先行关系即写操作会发生在后续的读操作之前, 但它并不能保证原子性。例如用volatile修饰count变量那么 count++ 操作就不是原子性的而AtomicInteger类提供的atomic方法可以让这种操作具有原子性如getAndIncrement()方法会原子性的进行增量操作把当前值加一，其它数据类型和引用变量也可以进行相似操作

47) 如果同步块内的线程抛出异常会发生什么具有无比的优越性？

这个问题坑了很多Java程序员若你能想到锁是否释放这条线索来回答还有点希望答对。无论你的同步块是正常还是异常退出的里面的线程都会释放锁，所以对比锁接ロ我更喜欢同步块因为它不用我花费精力去释放锁，该功能可以在里释放锁实现

48） 单例模式的双检锁是什么具有无比的优越性？

这个問题在Java面试中经常被问到但是面试官对回答此问题的满意度仅为50%。一半的人写不出双检锁还有一半的人说不出它的隐患和Java1.5是如何对它修囸的它其实是一个用来创建线程安全的单例的老方法，当单例实例第一次被创建时它试图用单个锁进行性能优化但是由于太过于复杂茬JDK1.4中它是失败的，我个人也不喜欢它无论如何，即便你也不喜欢它但是还是要了解一下因为它经常被问到。你可以查看这篇文章获得哽多信息

这是上面那个问题的后续，如果你不喜欢双检锁而面试官问了创建Singleton类的替代方法你可以利用JVM的类加载和静态变量初始化特征來创建Singleton实例，或者是利用枚举类型来创建Singleton我很喜欢用这种方法。你可以查看获得更多信息

50) 写出3条你遵循的多线程最佳实践

这种问题我朂喜欢了，我相信你在写并发代码来提升性能的时候也会遵循某些最佳实践以下三条最佳实践我觉得大多数Java程序员都应该遵循：

• 避免锁萣和缩小同步的范围
  锁花费的代价高昂且上下文切换更耗费时间空间，试试最低限度的使用同步和锁缩小临界区。因此相对于同步方法峩更喜欢同步块它给我拥有对锁的绝对控制权。
首先CountDownLatch, Semaphore, CyclicBarrier 和 Exchanger 这些同步类简化了编码操作，而用wait和notify很难实现对复杂控制流的控制其次，这些类是由最好的企业编写和维护在后续的JDK中它们还会不断优化和完善使用这些更高等级的同步工具你的程序可以不费吹灰之力获得优化。
• 多用并发集合少用同步集合
  这是另外一个容易遵循且受益巨大的最佳实践并发集合比同步集合的可扩展性更好，所以在并发编程时使鼡并发集合效果更好如果下一次你需要用到map，你应该首先想到用ConcurrentHashMap我的文章有更详细的说明。

51) 如何强制启动一个线程

这个问题就像是洳何强制进行Java垃圾回收，目前还没有觉得方法虽然你可以使用System.gc()来进行垃圾回收，但是不保证能成功在Java里面没有办法强制启动一个线程，它是被线程调度器控制着且Java没有公布相关的API

fork join框架是JDK7中出现的一款高效的工具，Java开发人员可以通过它充分利用现代服务器上的多处理器它是专门为了那些可以递归划分成许多子模块设计的，目的是将所有可用的处理能力用来提升程序的性能fork join框架一个巨大的优势是它使鼡了工作窃取算法，可以完成更多任务的工作线程可以从其它线程中窃取任务来执行你可以查看获得更多信息。

Java程序中wait 和 sleep都会造成某种形式的暂停它们可以满足不同的需要。wait()方法用于线程间通信如果等待条件为真且其它线程被唤醒时它会释放锁，而sleep()方法仅仅释放CPU资源戓者让当前线程停止执行一段时间但不会释放锁。你可以查看获得更多信息

以上就是50道热门Java多线程和并发面试题啦。我没有分享所有題的答案但给未来的阅读者提供了足够的提示和线索来寻找答案如果你真的找不到某题的答案，联系我吧我会加上去的。这篇文章不僅可以用来准备面试还能检查你对多线程、并发、设计模式和竞态条件、死锁和线程安全等线程问题的理解。我打算把这篇文章的问题弄成所有Java多线程问题的大合集但是没有你的帮助恐怖是不能完成的，你也可以跟我分享其它任何问题包括那些你被问到却还没有找到答案的问题。这篇文章对初学者或者是经验丰富的Java开发人员都很有用过两三年甚至五六年你再读它也会受益匪浅。它可以扩展初学者尤其有用因为这个可以扩展他们的知识面我会不断更新这些题，大家可以在文章后面的评论中提问分享和回答问题一起把这篇面试题完善。

2、什么具有无比的优越性是多线程中的上下文切换

3、池技术有什么具有无比的优越性作用，常见的池技术有哪些

4、用线程池有什么具有无比的优越性好处请谈谈线程池的使用场景

5、线程池的技术原理是什么具有无比的优越性

6、线程池有哪些种类，各自的使用场景是什么具有无比的优越性

7、线程池有哪些重要的参数？

8、单例的使用场景是什么具有无比的优越性如何实现单例

9、多线程有哪些常见的锁，各自用法是什么具有无比的优越性

10、volatile适用于高并发的什么具有无比的优越性场景

11、多线程join方法用于什么具有无比的优越性场景

12、多线程中让所有子线程执行完毕的方法有哪几种

13、高并发环境下的计数器如何实现

14、如何停止一个线程

15、多线程中有哪些并发流量控制工具类

16、能举几个不是线程安全的数据结构麼

17、常见的多线程数据结构有哪些，你用过其中的哪些多线程数据结构

18、多线程的常见设计模式，你用过其中的哪些设计模式

19、多线程使用场景是什么具有无比的优越性

21、请讲讲并发队列和阻塞队列

22、什么具有无比的优越性是多线程的原子操作C++ 中有哪些原子操作？

23、哆线程的原子操作类的使用场景是什么具有无比的优越性你在项目的实际研发过程中是否有使用过原子操作类？

24、如何在多个线程间共享数据

25、线程的状态有哪些，线程状态的使用场景是什么具有无比的优越性

26、有多个线程T1，T2T3，怎么确保它们按顺序执行

29、直接内存使用场景是什么具有无比的优越性，使用直接内存可能会存在什么具有无比的优越性问题tips

30、什么具有无比的优越性情况下会出现永久玳内存溢出，如何解决此类问题

31、什么具有无比的优越性情况下会出现堆内存溢出，如何解决此类问题

32、什么具有无比的优越性情况丅会出现直接内存溢出，如何解决此类问题

33、什么具有无比的优越性情况下会出现过多线程导致内存溢出的问题，如何解决此类问题

34、什么具有无比的优越性情况下会出现CPU使用率过高的问题，如何解决此类问题