多线程面试看这篇就够了

- 日理万妓 2022-01-27 02:37 338阅读 0赞

### Exception ###

\*\*异 常：\*\*★★★

异常处理原则：功能抛出几个异常，功能调用如果进行try处理，需要与之对应的catch处理代码块，这样的处理有针对性，抛几个就处理几个。

特殊情况：try对应多个catch时，如果有父类的catch语句块，一定要放在下面。

#### throw 和throws关键字的区别： ####

throw用于抛出异常对象，后面跟的是异常对象；throw用在函数内。

throws用于抛出异常类，后面跟的异常类名，可以跟多个，用逗号隔开。throws用在函数上。

#### final,finally,finalize的区别。（联动） ####

final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。

内部类要访问局部变量，局部变量必须定义成final类型，例如，一段代码……

finally是异常处理语句结构的一部分，表示总是执行。

finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集的方法时的其他资源回收，例如关闭文件等。JVM不保证此方法总被调用。

1、对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。

2、当用final修饰一个类时，表明这个类不能被继承。final类中的所有成员方法都会被隐式地指定为final方法。

3、使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。

在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升（现在的Java版本已经不需要使用final方法进行这些优化了）。类中所有的private方法都隐式地指定为fianl

#### 最常见的runtimeexception运行时异常？ ####

ClassCastException（类型转换异常）、NumberFormatException（格式化异常）、ArrayIndexOutOfBoundsException（数组越界异常）、ArithmeticException（算术异常）、NullPointerException（空指针异常）等等

这道题主要考查大家平时在项目开发过程中经常遇到的一些异常类型信息，通过这些异常来考查大家的项目经验与项目排错能力。

#### try\{\}里有一个return语句，那么紧跟在这个try后的finally\{\}里的code会不会被执行，什么时候被执行，在return前还是后?【杭州天眼科技】 ####

答案是在return之前。

程序代码的运行结果：

publicclassTest\{

publicstaticvoidmain(String\[\]args)\{

//TODOAuto-generatedmethodstub

System.*out*.println(newTest().test());;

staticinttest()

intx=1;

try

returnx;

finally

\++x;

\---------执行结果---------

运行结果是1，为什么呢？主函数调用子函数并得到结果的过程，好比主函数准备一个空罐子，当子函数要返回结果时，先把结果放在罐子里，然后再将程序逻辑返回到主函数。所谓返回，就是子函数说，我不运行了，你主函数继续运行吧，这没什么结果可言，结果是在说这话之前放进罐子里的。

下面的程序代码输出的结果是多少？

publicclasssmallT\{

publicstaticvoidmain(Stringargs\[\])\{

smallTt=newsmallT();

intb=t.get();

System.out.println(b);

publicintget()\{

try

return1;

finally

return2;

返回的结果是2。

我可以通过下面一个例子程序来帮助我解释这个答案，从下面例子的运行结果中可以发现，try中的return语句调用的函数先于finally中调用的函数执行，也就是说return语句先执行，finally语句后执行，所以，返回的结果是2。Return并不是让函数马上返回，而是return语句执行后，将把返回结果放置进函数栈中，此时函数并不是马上返回，它要执行finally语句后才真正开始返回。

在讲解答案时可以用下面的程序来帮助分析：

publicclassTest\{

/\*\*

\*@paramargsaddbyzxx,Dec9,2008

\*/

publicstaticvoidmain(String\[\]args)\{

//TODOAuto-generatedmethodstub

System.*out*.println(newTest().test());;

inttest()

try

returnfunc1();

finally

returnfunc2();

intfunc1()

System.*out*.println(“func1”);

return1;

intfunc2()

System.*out*.println(“func2”);

return2;

\-----------执行结果-----------------

func1

func2

结论：finally中的代码比return和break语句后执行。

#### Java的异常有哪几种，有什么区别？ ####

两大类，一般异常和运行时异常。

一般异常，这些异常是在定义方法时声明抛出的，这些异常必需用trycatch抛出，或throws处理，如果不处理，程序将编译失败。比如：IOException、FileNotFoundException、SQLException等。

**运行时异常是程序运行时可能报出的异常。可以用trycatch抓取，也可以不做任何处理。例如：NullPointerException异常就是一种比较常见的运行时异常。**

![Image 1][]

在 Java 中，所有的异常都有一个共同的祖先java.lang包中的 Throwable类。Throwable：  
有两个重要的子类：

Exception（异常） 和 Error（错误） ，二者都是 Java  
异常处理的重要子类，各自都包含大量子类。

Error（错误）:是程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时  
JVM（Java 虚拟机）出现的问题。例如，Java虚拟机运行错误（Virtual  
MachineError），当JVM 不再有继续执行操作所需的内存资源时，将出现  
OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一

般会选择线程终止。

这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，如Java虚拟机运行错误（VirtualMachineError）、类定义错误（NoClassDefFoundError）等。这些错误是不可查的，因为它们在应用程序的控制和处理能力之  
外，而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的异常状况。在  
Java中，错误通过Error的子类描述。

Exception（异常）:是程序本身可以处理的异常。Exception 类有一个重要的子类  
RuntimeException。

RuntimeException  
异常由Java虚拟机抛出。NullPointerException（要访问的变量没有引用任何对象时，抛出该异常）、ArithmeticException（算术运算异常，一个整数除以0时，抛出该异常）和ArrayIndexOutOfBoundsException  
（下标越界异常）。

注意：异常和错误的区别：异常能被程序本身可以处理，错误是无法处理。

Throwable类常用方法

public string getMessage():返回异常发生时的详细信息

public string toString():返回异常发生时的简要描述

public string  
getLocalizedMessage():返回异常对象的本地化信息。使用Throwable的子类覆盖这个方法，可

以声称本地化信息。如果子类没有覆盖该方法，则该方法返回的信息与getMessage（）返回的结果相同

public void printStackTrace():在控制台上打印Throwable对象封装的异常信息

异常处理总结

try  
块：用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。

catch 块：用于处理try捕获到的异常。

inally  
块：无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。

在以下4种特殊情况下，finally块不会被执行：

1.  在finally语句块中发生了异常。
2.  在前面的代码中用了System.exit()退出程序。
3.  程序所在的线程死亡。
4.  关闭CPU。

#### JAVA语言如何进行异常处理，关键字：throws,throw,try,catch,finally分别代表什么意义？在try块中可以抛出异常吗？ ####

Java使用面向对象的方式来处理异常，它把程序中发生的每个异常也都分别封装到一个对象来表示的，该对象中包含有异常的信息。而throws\\throw\\try、catch、finally就是Java中用来对异常进行处理的几个关键字，在Java编程中规容Java编译器强制普通异常必须try…catch处理或用throws声明继续抛给上层调用方法处理，一般异常必须要求被捕获和处理，而系统异常可以处理也可以不处理，所以编译器不强制用try…catch处理或用throws、throw声明异常。而finally一般与try或try\\catch一起使用做为异常的最后处理出口。

#### Java中的异常处理机制的简单原理和应用。 ####

异常是指java程序运行时（非编译）所发生的非正常情况或错误，与现实生活中的事件很相似，现实生活中的事件可以包含事件发生的时间、地点、人物、情节等信息，可以用一个对象来表示，Java使用面向对象的方式来处理异常，它把程序中发生的每个异常也都分别封装到一个对象来表示的，该对象中包含有异常的信息。

Java对异常进行了分类，不同类型的异常分别用不同的Java类表示，所有异常的根类为java.lang.Throwable，Throwable下面又派生了两个子类：Error和Exception，Error表示应用程序本身无法克服和恢复的一种严重问题，程序只有死的份了，例如，说内存溢出和线程死锁等系统问题。Exception表示程序还能够克服和恢复的问题，其中又分为系统异常和普通异常，系统异常是软件本身缺陷所导致的问题，也就是软件开发人员考虑不周所导致的问题，软件使用者无法克服和恢复这种问题，但在这种问题下还可以让软件系统继续运行或者让软件死掉，例如，数组脚本越界（ArrayIndexOutOfBoundsException），空指针异常（NullPointerException）、类转换异常（ClassCastException）；普通异常是运行环境的变化或异常所导致的问题，是用户能够克服的问题，例如，网络断线，硬盘空间不够，发生这样的异常后，程序不应该死掉。

java为系统异常和普通异常提供了不同的解决方案，编译器强制普通异常必须try…catch处理或用throws声明继续抛给上层调用方法处理，所以普通异常也称为checked异常，而系统异常可以处理也可以不处理，所以，编译器不强制用try…catch处理或用throws声明，所以系统异常也称为unchecked异常。

#### Error和exception的区别与联系？ ####

error表示恢复不是不可能,但很困难的情况下的一种严重问题。比如说内存溢,网络故障等，不可能指望程序能处理的一类错误。

Exception表示一种由程序设计或实现问题，表示程序运行时异常，如空指针异常数组下标越界。像我们常说的异常处理，就是属于这类，一般程序可以捕获和处理这些异常。

### 线程 ###

关于 Java多线程，在面试的时候，问的比较多的就是

1.  悲观锁和乐观锁（ 具体：面试必备之乐观锁与悲观锁）、

②synchronized和lock区别以及volatile和synchronized的区别，

③可重入锁与非可重入锁的区别、

④多线程是解决什么问题的、⑤线程池解决什么问题、⑥线程池的原理、⑦线程池使用时的注意事项、⑧AQS原理、⑨ReentranLock源码，设计原理，整体过程  
等等问题。

面试官在多线程这一部分很可能会问你有没有在项目中实际使用多线程的经历。所以，如果你在你的项目中有实际使用Java多线程的经历  
的话，会为你加分不少哦！

#### 多线程和并发的区别 ####

多线程是为了提高程序的运行效率。

并发是同一时刻同时访问。

#### 在静态方法上使用同步时会发生什么事？ ####

同步静态方法时会获取该类的“Class”对象，所以当一个线程进入同步的静态方法中时，

线程监视器获取类本身的对象锁，其它线程不能进入这个类的任何静态同步方法。

它不像实例方法，因为多个线程可以同时访问不同实例同步实例方法。

#### 当一个同步方法已经执行，线程能够调用对象上的非同步实例方法吗？ ####

可以，一个非同步方法总是可以被调用而不会有任何问题。

实际上，Java  
没有为非同步方法做任何检查，锁对象仅仅在同步方法或者同步代码块中检查。

如果一个方法没有声明为同步，即使你在使用共享数据Java照样会调用，而不会做检查是否安全，

所以在这种情况下要特别小心。一个方法是否声明为同步取决于临界区访问(critial  
section access)，

如果方法不访问临界区(共享资源或者数据结构)就没必要声明为同步的。

#### 在一个对象上两个线程可以调用两个不同的同步实例方法吗？ ####

不能，因为一个对象已经同步了实例方法，线程获取了对象的对象锁。

所以只有执行完该方法释放对象锁后才能执行其它同步方法。

#### 什么是线程饿死，什么是活锁？ ####

线程饿死和活锁虽然不像死锁一样是常见的问题，但是对于并发编程的设计者来说就像一次邂逅一样。

当所有线程阻塞，或者由于需要的资源无效而不能处理，不存在非阻塞线程使资源可用。

JavaAPI 中线程活锁可能发生在以下情形：

当所有线程在程序中执行 Object.wait (0)，参数为 0 的 wait 方法。

程序将发生活锁直到在相应的对象上有线程调用 Object.notify ()或者 Object.notifyAll  
()。

当所有线程卡在无限循环中。

#### 多线程安全问题的原因： ####

通过图解：发现一个线程在执行多条语句时，并运算同一个数据时，在执行过程中，其他线程参与进来，并操作了这个数据。导致到了错误数据的产生。

\*\*涉及到两个因素： \*\*

1，多个线程在操作共享数据。

2，有多条语句对共享数据进行运算。

原因：这多条语句，在某一个时刻被一个线程执行时，还没有执行完，就被其他线程执行了。

#### 解决安全问题的原理： ####

只要将操作共享数据的语句在某一时段让一个线程执行完，在执行过程中，其他线程不能进来执行就可以解决这个问题。

如何进行多句操作共享数据代码的封装呢？

\*\*java中提供了一个解决方式：就是同步代码块。 \*\*

格式：

**synchronized**(对象) \{ \*\*// 任意对象都可以。这个对象就是锁。 \*\*

**需要被同步的代码；**

**Synchronized**(自己得会写得出)

#### 什么时候产生死锁,该怎么办? ####

#### sleep()和wait()区别 ####

分析这两个方法：从执行权和锁上来分析：

wait：

sleep：

wait：

Sleep：

\-------------------------------

sleep方法（Tread类）：

必须指定时间，时间到自动从冻结状态转成运行状态(临时阻塞状态)。

线程主动放弃CPU，使得线程在指定的时间内进入阻塞状态，不能得到CPU时间，指定的时间一过，线程重新进入可执行状态。典型地，sleep()被用在等待某个资源就绪的情形：测试发现条件不满足后，让线程阻塞一段时间后重新测试，直到条件满足为止。

sleep线程会释放执行权，但不是不释放锁。

wait方法（Object类）：

使线程进入阻塞状态，它有两种形式，

一种允许指定以毫秒为单位的一段时间作为参数，

另一种没有参数，当指定时间参数时对应的notify()被调用或者超出指定时间时线程重新进入可执行状态，后者则必须对应的notify()被调用。

wait线程会释放执行权，而且线程会释放锁。

进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备获取对象锁进入运行状态。

#### Wait()与Notify ()区别? ####

**Wait让当前线程有运行状态变为等待状态，和同步一起使用**

**Notify 唤醒现在正在等待的状态,和同步一起使用**

#### 创建线程的方式及实现（必问） ####

Java中创建线程主要有三种方式：

##### 继承Thread类创建线程类 #####

继承Thread ，由子类复写run方法。

（1）定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。

（2）创建Thread子类的实例，即创建了线程对象。

（3）调用线程对象的start()方法来启动该线程。并执行run方法

上述代码中Thread.currentThread()方法返回当前正在执行的线程对象。getName()方法返回调用该方法的线程的名字。

线程状态：

新建：start()

运行：具备执行资格，同时具备执行权；

冻结：sleep(time),wait()—notify()唤醒；线程释放了执行权，同时释放执行资格；

临时阻塞状态：线程具备cpu的执行资格，没有cpu的执行权；

消亡：stop()

##### 通过Runnable接口创建线程类 #####

步骤：

（1）定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。

（2）创建Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。

将实现了Runnable接口的子类对象作为实际参数传递给Thread类中的构造函数。  
为什么要传递呢？因为要让线程对象明确要运行的run方法所属的对象。

（3）调用线程对象的start()方法来启动该线程。并运行Runnable接口子类中的run方法。

<table> 
 <thead> 
  <tr> 
   <th>package com.thread; class RunnableThreadTest implements Runnable { private int i; @Override public void run() { for (i = 0; i &lt; 100; i++) { System.out.println(Thread.currentThread().getName() + “” + i); } } public static void main(String[] args) { for (int i = 0; i &lt; 100; i++) { System.out.println(Thread.currentThread().getName() + “” + i); if (i == 20) { RunnableThreadTest rtt = new RunnableThreadTest(); new Thread(rtt, “新线程1”).start(); new Thread(rtt, “新线程2”).start(); } } } }</th> 
  </tr> 
 </thead> 
 <tbody></tbody> 
</table>

##### 通过Callable和Future创建线程 #####

（1）创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。

（2）创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。

（3）使用FutureTask对象作为Thread对象的target创建并启动新线程。

（4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

packagecom.thread;

importjava.util.concurrent.Callable;

importjava.util.concurrent.ExecutionException;

importjava.util.concurrent.FutureTask;

publicclassCallableThreadTestimplementsCallable<Integer>

publicstaticvoidmain(String\[\]args)

CallableThreadTestctt=newCallableThreadTest();

FutureTask<Integer>ft=newFutureTask<>(ctt);

for(inti=0;i<100;i++)

System.out.println(Thread.currentThread().getName()+“的循环变量i的值”+i);

if(i==20)

newThread(ft,“有返回值的线程”).start();

try

System.out.println(“子线程的返回值：”+ft.get());

\}catch(InterruptedExceptione)

e.printStackTrace();

\}catch(ExecutionExceptione)

e.printStackTrace();

@Override

publicIntegercall()throwsException

inti=0;

for(;i<100;i++)

System.out.println(Thread.currentThread().getName()+""+i);

returni;

##### 创建线程的三种方式的对比 #####

采用实现Runnable、Callable接口的方式创见多线程时，优势是：

线程类只是实现了Runnable接口或Callable接口，还可以继承其他类。

在这种方式下，多个线程可以共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。

劣势是：

编程稍微复杂，如果要访问当前线程，则必须使用Thread.currentThread()方法。

使用继承Thread类的方式创建多线程时优势是：

编写简单，如果需要访问当前线程，则无需使用Thread.currentThread()方法，直接使用this即可获得当前线程。

劣势是：

线程类已经继承了Thread类，所以不能再继承其他父类。

#### 启动一个线程用什么方法？【北京永中】 ####

使用Thread类的start()方法来启动一个线程，使线程进入就绪状态。如果自定义的类是Thread类的子类的话，可以直接使用Start()来启，如果是实现的Runnable接口的话，还要将该类的实例作为参数传入到Thread对象中来启动。

#### synchronized ####

##### 对于 synchronized 关键字的了解 #####

synchronized关键字解决的是多个线程之间访问资源的同步性，synchronized关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。

另外，在 Java  
早期版本中，synchronized属于重量级锁，效率低下，因为监视器锁（monitor）是依赖于底层的操作系统的  
Mutex Lock 来实现的，Java  
的线程是映射到操作系统的原生线程之上的。如果要挂起或者唤醒一个线程，都需要操作系统帮忙完成，而操作系统实现线程之间的切换时需要从用户态转换到内核态，这个状态之间的转换需要相对比较长的时间，时间成本相对较高，这也是为什么早期的  
synchronized 效率低的原因。庆幸的是在 Java 6 之后

Java 官方对从 JVM 层面对synchronized 较大优化，所以现在的 synchronized  
锁效率也优化得很不错了。JDK1.6对锁的实现引入了大量的优化，如自旋锁、适应性自旋锁、锁消除、锁粗化、偏向锁、轻量级锁等技术来减少锁操作的开销。

##### 说说自己是怎么使用 synchronized 关键字，在项目中用到了吗 #####

synchronized关键字最主要的三种使用方式：

修饰实例方法，作用于当前对象实例加锁，进入同步代码前要获得当前对象实例的锁

修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁  
。也就是给当前类加锁，会作用于类的所有对象实例，因为静态成员不属于任何一个实例对象，是类成员（static  
表明这是该类的一个静态资源，不管new了多少个对象，只有一份，所以对该类的所有对象都加了锁）。所以如果一个线程A调用一个实例对象的非静态  
synchronized 方法，而线程B需要调用这个实例对象所属类的静态 synchronized  
方法，是允许的，不会发生互斥现象，因为访问静态 synchronized  
方法占用的锁是当前类的锁，而访问非静态synchronized  
方法占用的锁是当前实例对象锁。

修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。  
和 synchronized  
方法一样，synchronized(this)代码块也是锁定当前对象的。synchronized 关键字加到  
static 静态方法和synchronized(class)代码块上都是是给 Class  
类上锁。这里再提一下：synchronized关键字加到非 static  
静态方法上是给对象实例上锁。另外需要注意的是：尽量不要使用 synchronized(String  
a) 因为JVM中，字符串常量池具有缓冲功能！

下面我已一个常见的面试题为例讲解一下 synchronized 关键字的具体使用。

面试中面试官经常会说：“单例模式了解吗？来给我手写一下！给我解释一下双重检验锁方式实现单例模式的原理呗！”

双重校验锁实现对象单例（线程安全）

public class Singleton \{

private volatile static Singleton uniqueInstance;

private Singleton() \{

public static Singleton getUniqueInstance() \{

//先判断对象是否已经实例过，没有实例化过才进入加锁代码

if (uniqueInstance == null) \{

//类对象加锁

synchronized (Singleton.class) \{

if (uniqueInstance == null) \{

uniqueInstance = new Singleton();

return uniqueInstance;

另外，需要注意 uniqueInstance 采用 volatile 关键字修饰也是很有必要。

uniqueInstance 采用 volatile 关键字修饰也是很有必要的， uniqueInstance = new  
Singleton(); 这段代码其实是分为三步执行：

1.  为 uniqueInstance 分配内存空间
2.  初始化 uniqueInstance
3.  将 uniqueInstance 指向分配的内存地址

但是由于 JVM 具有指令重排的特性，执行顺序有可能变成  
1->3->2。指令重排在单线程环境下不会出先问题，但是在多线程环境下会导致一个线程获得还没有初始化的实例。例如，线程  
T1 执行了 1 和 3，此时 T2 调用getUniqueInstance() 后发现 uniqueInstance  
不为空，因此返回 uniqueInstance，但此时 uniqueInstance 还未被初始化。

使用 volatile 可以禁止 JVM 的指令重排，保证在多线程环境下也能正常运行。

##### synchronized 关键字的底层原理 #####

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

1.  synchronized 同步语句块的情况

public class SynchronizedDemo \{

public void method() \{

synchronized (this) \{

System.out.println(“synchronized 代码块”);

通过 JDK 自带的 javap 命令查看 SynchronizedDemo  
类的相关字节码信息：首先切换到类的对应目录执行 javac SynchronizedDemo.java  
命令生成编译后的 .class 文件，然后执行 javap -c -s -v –l SynchronizedDemo.class  
。

![Image 1][]

从上面我们可以看出：

synchronized 同步语句块的实现使用的是 monitorenter 和 monitorexit 指令，其中  
monitorenter 指令指向同步代码块的开始位置，monitorexit  
指令则指明同步代码块的结束位置。 当执行 monitorenter  
指令时，线程试图获取锁也就是获取  
monitor(monitor对象存在于每个Java对象的对象头中，synchronized  
锁便是通过这种方式获取锁的，也是为什么Java中任意对象可以作为锁的原因)  
的持有权.当计数器为0则可以成功获取，获取后将锁计数器设为1也就是加1。相应的在执行  
monitorexit  
指令后，将锁计数器设为0，表明锁被释放。如果获取对象锁失败，那当前线程就要阻塞等待，直到锁被另外一个线程释放为止。

1.  synchronized 修饰方法的的情况

public class SynchronizedDemo2 \{

public synchronized void method() \{

System.out.println(“synchronized 方法”);

![Image 1][]

synchronized 修饰的方法并没有 monitorenter 指令和 monitorexit  
指令，取得代之的确实是ACC\_SYNCHRONIZED  
标识，该标识指明了该方法是一个同步方法，JVM  
通过该ACC\_SYNCHRONIZED访问标志来辨别一个方法是否声明为同步方法，从而执行相应的同步调用。

##### 说说 JDK1.6 之后的synchronized 关键字底层做了哪些优化，可以详细介绍一下这些优化吗 #####

JDK1.6  
对锁的实现引入了大量的优化，如偏向锁、轻量级锁、自旋锁、适应性自旋锁、锁消除、锁粗化等技术来减少锁操作的开销。

锁主要存在四种状态，依次是：无锁状态、偏向锁状态、轻量级锁状态、重量级锁状态，他们会随着竞争的激烈而逐渐升级。注意锁可以升级不可降级，这种策略是为了提高获得锁和释放锁的效率。

关于这几种优化的详细信息可以查看：synchronized 关键字使用、底层原理、JDK1.6  
之后的底层优化以及和ReenTrantLock 的对比

##### 谈谈 synchronized和ReenTrantLock 的区别 #####

①两者都是可重入锁

两者都是可重入锁。“可重入锁”概念是：自己可以再次获取自己的内部锁。比如一个线程获得了某个对象的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁的时候还是可以获取的，如果不可锁重入的话，就会造成死锁。同一个线程每次获取锁，锁的计数器都自增1，所以要等到锁的计数器下降为0时才能释放锁。

②synchronized依赖于JVM而ReenTrantLock 依赖于 API

synchronized 是依赖于 JVM 实现的，前面我们也讲到了 虚拟机团队在 JDK1.6 为  
synchronized关键字进行了很多优化，但是这些优化都是在虚拟机层面实现的，并没有直接暴露给我们。ReenTrantLock是JDK  
层面实现的（也就是 API  
层面，需要lock()和unlock方法配合try/finally语句块来完成），所以我们可以通过查看它的源代码，来看它是如何实现的。

③ReenTrantLock比synchronized 增加了一些高级功能

相比synchronized，ReenTrantLock增加了一些高级功能。主要来说主要有三点：①等待可中断；②可实现公平锁；

1.  可实现选择性通知（锁可以绑定多个条件）

ReenTrantLock提供了一种能够中断等待锁的线程的机制，通过lock.lockInterruptibly()来实现这个机制。也就是说正在等待的线程可以选择放弃等待，改为处理其他事情。

ReenTrantLock可以指定是公平锁还是非公平锁。而synchronized只能是非公平锁。所谓的公平锁就是先等待的线程先获得锁。  
ReenTrantLock默认情况是非公平的，可以通过 ReenTrantLock类的ReentrantLock(boolean  
fair) 构造方法来制定是否是公平的。

synchronized关键字与wait()和notify/notifyAll()方法相结合可以实现等待/通知机制，ReentrantLock类当然也可以实现，但是需要借助于Condition接口与newCondition()  
方法。Condition是JDK1.5之后才有的，它具有很好的灵活性，比如可以实现多路通知功能也就是在一个Lock对象中可以创建多个Condition实例（即对象监视器），线程对象可以注册在指定的Condition中，从而可以有选择性的进行线程通知，在调度线程上更加灵活。  
在使用notify/notifyAll()方法进行通知时，被通知的线程是由 JVM  
选择的，用ReentrantLock类结合Condition实例可以实现“选择性通知”  
，这个功能非常重要，而且是Condition接口默认提供的。而synchronized关键字就相当于整个Lock对象中只有一个Condition实例，所有的线程都注册在它一个身上。如果执行notifyAll()方法的话就会通知所有处于等待状态的线程这样会造成很大的效率问题，而Condition实例的signalAll()方法  
只会唤醒注册在该Condition实例中的所有等待线程。

如果你想使用上述功能，那么选择ReenTrantLock是一个不错的选择。

1.  性能已不是选择标准

##### 说说 synchronized 关键字和 volatile 关键字的区别 #####

synchronized关键字和volatile关键字比较

volatile关键字是线程同步的轻量级实现，所以volatile性能肯定比synchronized关键字要好。但是volatile关键字只能用于变量而synchronized关键字可以修饰方法以及代码块。synchronized关键字在JavaSE1.6之后进行了主要包括为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁以及其它各种优化之后执行效率有了显著提升，实际开发中使用synchronized  
关键字的场景还是更多一些。  
多线程访问volatile关键字不会发生阻塞，而synchronized关键字可能会发生阻塞

volatile关键字能保证数据的可见性，但不能保证数据的原子性。synchronized关键字两者都能保证。

volatile关键字主要用于解决变量在多个线程之间的可见性，而  
synchronized关键字解决的是多个线程之间访问资源的同步性。

##### synchronized和java.util.concurrent.locks.Lock的异同？ #####

syn自动上锁，代码执行完毕后自动解锁。

lock手动上锁解锁。

**Lock接口可以尝试非阻塞地获取锁  
当前线程尝试获取锁。如果这一时刻锁没有被其他线程获取到，则成功获取并持有锁。**

**Lock接口能被中断地获取锁 与 synchronized  
不同，获取到锁的线程能够响应中断，当获取到的锁的线程被中断时，中断异常将会被抛出，同时锁会被释放。**

**Lock接口在指定的截止时间之前获取锁，如果截止时间到了依旧无法获取锁，则返回。**

主要相同点：Lock能完成synchronized所实现的所有功能

主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。

Lock还有更强大的功能，例如，它的tryLock方法可以非阻塞方式去拿锁。

#### 线程池 ####

##### 什么是线程池？ #####

线程池是指在初始化一个多线程应用程序过程中创建一个线程集合，然后在需要执行新的任务时重用这些线程而不是新建一个线程。线程池中线程的数量通常完全取决于可用内存数量和应用程序的需求。然而，增加可用线程数量是可能的。线程池中的每个线程都有被分配一个任务，一旦任务已经完成了，线程回到池子中并等待下一次分配任务。

利用线程池节约线程创建，销毁占用的资源。

##### 为什么要使用线程池 #####

线程池提供了一种限制和管理资源（包括一个任务）。每个线程池还维护一些基本信息，例如已完成任务数量。

*  降低资源消耗：通过重复利用已创建的线程降低线程的创建和销毁造成的消耗。
 *  提高响应速度：当任务到达时，任务可以不需要等到线程创建就能立即执行。
 *  提高线程的可管理性：线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统稳定性，使用线程池可以进行统一的分配，调优和监控。

##### 讲讲线程池的实现原理 #####

主要是ThreadPoolExecutor的实现原理

[Java并发编程：线程池的使用][Java]

##### 实现Runnable接口和Callable接口的区别 #####

如果想让线程池执行任务的话需要实现的Runnable接口或Callable接口。  
Runnable接口或Callable接口实现类都可以被ThreadPoolExecutor或ScheduledThreadPoolExecutor执行。两者的区别在于  
Runnable 接口不会返回结果但是 Callable 接口可以返回结果。

备注： 工具类 Executors 可以实现 Runnable 对象和 Callable 对象之间的相互转换。

（ Executors.callable（Runnable task） 或 Executors.callable（Runnable  
task，Object resule） ）。

##### 执行execute()方法和submit()方法的区别是什么呢？ #####

1.  execute()  
    方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功与否；

2)submit()方法用于提交需要返回值的任务。线程池会返回一个future类型的对象，通过这个future对象可以判断任务是否执行成功，并且可以通过future的get()方法来获取返回值，get()方法会阻塞当前线程直到任务完成，而使用get（long  
timeout，TimeUnit unit）  
方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行完。

##### 如何创建线程池 #####

《阿里巴巴Java开发手册》中强制线程池不允许使用 Executors 去创建，而是通过  
ThreadPoolExecutor  
的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险

Executors 返回线程池对象的弊端如下：

FixedThreadPool 和 SingleThreadExecutor ： 允许请求的队列长度为  
Integer.MAX\_VALUE,可能堆积大量的请求，从而导致OOM。

CachedThreadPool 和 ScheduledThreadPool ： 允许创建的线程数量为  
Integer.MAX\_VALUE ，可能会创建大量线程，从而导致OOM。

方式一：通过构造方法实现

![Image 1][]

方式二：通过Executor 框架的工具类Executors来实现  
我们可以创建三种类型的ThreadPoolExecutor：

FixedThreadPool ：  
该方法返回一个固定线程数量的线程池。该线程池中的线程数量始终不变。当有一个新的任务提交时，线程池中若有空闲线程，则立即执行。若没有，则新的任务会被暂存在一个任务队列中，待有线程空闲时，便处理在任务队列中的任务。

SingleThreadExecutor：  
方法返回一个只有一个线程的线程池。若多余一个任务被提交到该线程池，任务会被保存在一个任务队列中，待线程空闲，按先入先出的顺序执行队列中的任务。

CachedThreadPool：  
该方法返回一个可根据实际情况调整线程数量的线程池。线程池的线程数量不确定，但若有空闲线程可以复用，则会优先使用可复用的线程。若所有线程均在工作，又有新的任务提交，则会创建新的线程处理任务。所有线程在当前任务执行完毕后，将返回线程池进行复用。

对应Executors工具类中的方法如图所示：

![Image 1][]

##### 线程池的几种方式 #####

newFixedThreadPool(intnThreads)

创建一个固定长度的线程池，每当提交一个任务就创建一个线程，直到达到线程池的最大数量，这时线程规模将不再变化，当线程发生未预期的错误而结束时，线程池会补充一个新的线程

**newCachedThreadPool()**

创建一个可缓存的线程池，如果线程池的规模超过了处理需求，将自动回收空闲线程，而当需求增加时，则可以自动添加新线程，线程池的规模不存在任何限制

**newSingleThreadExecutor()**

这是一个单线程的Executor，它创建单个工作线程来执行任务，如果这个线程异常结束，会创建一个新的来替代它；它的特点是能确保依照任务在队列中的顺序来串行执行

**newScheduledThreadPool(intcorePoolSize)**

创建了一个固定长度的线程池，而且以延迟或定时的方式来执行任务，类似于Timer。

举个栗子

1.  privatestaticfinalExecutorexec=Executors.newFixedThreadPool(50);
2.  Runnablerunnable=newRunnable()\{
3.  publicvoidrun()\{
4.  …
5.  \}
6.  \}
7.  exec.execute(runnable);
8.  Callable<Object>callable=newCallable<Object>()\{
9.  publicObjectcall()throwsException\{
10. returnnull;
11. \}
12. \};
13. Futurefuture=executorService.submit(callable);
14. future.get();*//等待计算完成后，获取结果*
15. future.isDone();*//如果任务已完成，则返回true*
16. future.isCancelled();*//如果在任务正常完成前将其取消，则返回true*
17. future.cancel(true);*//试图取消对此任务的执行，true中断运行的任务，false允许正在运行的任务运行完成*

参考：

[创建线程池的几种方式][Link 1]

##### 线程池四种创建方式，区别和使用场景。 #####

Java通过Executors（jdk1.5并发包）提供四种线程池，分别为：

newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

newFixedThreadPool  
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。

newSingleThreadExecutor  
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO,  
LIFO, 优先级)执行。

#### Atomic 原子类的 4 连击 ####

##### 介绍一下Atomic 原子类 #####

Atomic  
翻译成中文是原子的意思。在化学上，我们知道原子是构成一般物质的最小单位，在化学反应中是不可分割的。在我们这里  
Atomic  
是指一个操作是不可中断的。即使是在多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程干扰。

所以，所谓原子类说简单点就是具有原子/原子操作特征的类。

并发包 java.util.concurrent 的原子类都存放在 java.util.concurrent.atomic  
下,如下图所示。

![Image 1][]

##### JUC 包中的原子类是哪4类? #####

基本类型

使用原子的方式更新基本类型

AtomicInteger：整形原子类

AtomicLong：长整型原子类

AtomicBoolean ：布尔型原子类

数组类型

使用原子的方式更新数组里的某个元素

AtomicIntegerArray：整形数组原子类

AtomicLongArray：长整形数组原子类

AtomicReferenceArray ：引用类型数组原子类

引用类型

AtomicReference：引用类型原子类

AtomicStampedRerence：原子更新引用类型里的字段原子类

AtomicMarkableReference ：原子更新带有标记位的引用类型

对象的属性修改类型

AtomicIntegerFieldUpdater:原子更新整形字段的更新器

AtomicLongFieldUpdater：原子更新长整形字段的更新器

AtomicStampedReference  
：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于解决原子的更新数据和数据的版本号，可以解决使用  
CAS 进行原子更新时可能出现的 ABA 问题。

##### 讲讲 AtomicInteger 的使用 #####

AtomicInteger 类常用方法

public final int get() //获取当前的值

public final int getAndSet(int newValue)//获取当前的值，并设置新的值

public final int getAndIncrement()//获取当前的值，并自增

public final int getAndDecrement() //获取当前的值，并自减

public final int getAndAdd(int delta) //获取当前的值，并加上预期的值

boolean compareAndSet(int expect, int update)  
//如果输入的数值等于预期值，则以原子方式将该值设置

为输入值（update）

public final void lazySet(int newValue)//最终设置为newValue,使用 lazySet  
设置之后可能导致其他线

程在之后的一小段时间内还是可以读到旧的值。

AtomicInteger 类的使用示例

使用 AtomicInteger 之后，不用对 increment() 方法加锁也可以保证线程安全。

class AtomicIntegerTest \{

private AtomicInteger count = new AtomicInteger();

//使用AtomicInteger之后，不需要对该方法加锁，也可以实现线程安全。

public void increment() \{

count.incrementAndGet();

public int getCount() \{

return count.get();

##### 介绍一下 AtomicInteger 类的原理 #####

AtomicInteger 线程安全原理简单分析

AtomicInteger 类的部分源码：

// setup to use Unsafe.compareAndSwapInt for  
updates（更新操作时提供“比较并替换”的作用）

private static final Unsafe unsafe = Unsafe.getUnsafe();

private static final long valueOffset;

static \{

try \{

valueOffset = unsafe.objectFieldOffset

(AtomicInteger.class.getDeclaredField(“value”));

\} catch (Exception ex) \{ throw new Error(ex); \}

private volatile int value;

AtomicInteger 类主要利用 CAS (compare and swap) + volatile 和 native  
方法来保证原子操作，从而避免synchronized 的高开销，执行效率大为提升。

CAS的原理是拿期望的值和原本的一个值作比较，如果相同则更新成新的值。UnSafe 类的  
objectFieldOffset()  
方法是一个本地方法，这个方法是用来拿到“原来的值”的内存地址，返回值是  
valueOffset。另外 value 是一个volatile变量，在内存中可见，因此 JVM  
可以保证任何时刻任何线程总能拿到该变量的最新值。

关于 Atomic 原子类这部分更多内容可以查看我的这篇文章：并发编程面试必备：JUC 中的  
Atomic 原子类总结

#### AQS ####

##### AQS 介绍 #####

AQS的全称为（AbstractQueuedSynchronizer），这个类在java.util.concurrent.locks包下面。

![Image 1][]

AQS是一个用来构建锁和同步器的框架，使用AQS能简单且高效地构造出应用广泛的大量的同步器，比如我们提到的

ReentrantLock，Semaphore，其他的诸如ReentrantReadWriteLock，SynchronousQueue，FutureTask等等皆是

基于AQS的。当然，我们自己也能利用AQS非常轻松容易地构造出符合我们自己需求的同步器。

##### AQS 原理分析 #####

AQS 原理这部分参考了部分博客，在5.2节末尾放了链接。

在面试中被问到并发知识的时候，大多都会被问到“请你说一下自己对于AQS原理的理解”。下面给大家一个示例供大家参加，面试不是背题，大家一定要假如自己的思想，即使加入不了自己的思想也要保证自己能够通俗的讲出来而不是背出来。

下面大部分内容其实在AQS类注释上已经给出了，不过是英语看着比较吃力一点，感兴趣的话可以看看源码。

AQS 原理概览

AQS核心思想是，如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制AQS是用CLH队列锁实现的，即将暂时获取不到锁的线程加入到队列中。

CLH(Craig,Landin,and  
Hagersten)队列是一个虚拟的双向队列（虚拟的双向队列即不存在队列实例，仅存在结点之间的关联关系）。AQS是将每条请求共享资源的线程封装成一个CLH锁队列的一个结点（Node）来实现锁的分配。

看个AQS(AbstractQueuedSynchronizer)原理图：

![Image 1][]

AQS使用一个int成员变量来表示同步状态，通过内置的FIFO队列来完成获取资源线程的排队工作。AQS使用CAS对该

同步状态进行原子操作实现对其值的修改。

private volatile int state;//共享变量，使用volatile修饰保证线程可见性

状态信息通过procted类型的getState，setState，compareAndSetState进行操作

//返回同步状态的当前值

protected final int getState() \{

return state;

// 设置同步状态的值

protected final void setState(int newState) \{

state = newState;

//原子地（CAS操作）将同步状态值设置为给定值update如果当前同步状态的值等于expect（期望值）

protected final boolean compareAndSetState(int expect, int update) \{

return unsafe.compareAndSwapInt(this, stateOffset, expect, update);

##### AQS 对资源的共享方式 #####

AQS定义两种资源共享方式

Exclusive（独占）：只有一个线程能执行，如ReentrantLock。又可分为公平锁和非公平锁：

公平锁：按照线程在队列中的排队顺序，先到者先拿到锁

非公平锁：当线程要获取锁时，无视队列顺序直接去抢锁，谁抢到就是谁的

Share（共享）：多个线程可同时执行，如Semaphore/CountDownLatch。Semaphore、

CountDownLatCh、 CyclicBarrier、ReadWriteLock 我们都会在后面讲到。

ReentrantReadWriteLock  
可以看成是组合式，因为ReentrantReadWriteLock也就是读写锁允许多个线程同时对某

一资源进行读。

不同的自定义同步器争用共享资源的方式也不同。自定义同步器在实现时只需要实现共享资源  
state 的获取与释放方

式即可，至于具体线程等待队列的维护（如获取资源失败入队/唤醒出队等），AQS已经在顶层实现好了。

5.2.3 AQS底层使用了模板方法模式

同步器的设计是基于模板方法模式的，如果需要自定义同步器一般的方式是这样（模板方法模式很经典的一个应

用）：

使用者继承AbstractQueuedSynchronizer并重写指定的方法。（这些重写方法很简单，无非是对于共享资源

state的获取和释放）

将AQS组合在自定义同步组件的实现中，并调用其模板方法，而这些模板方法会调用使用者重写的方法。

这和我们以往通过实现接口的方式有很大区别，这是模板方法模式很经典的一个运用。

AQS使用了模板方法模式，自定义同步器时需要重写下面几个AQS提供的模板方法：

isHeldExclusively()//该线程是否正在独占资源。只有用到condition才需要去实现它。

tryAcquire(int)//独占方式。尝试获取资源，成功则返回true，失败则返回false。

tryRelease(int)//独占方式。尝试释放资源，成功则返回true，失败则返回false。

tryAcquireShared(int)//共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成

功，且有剩余资源。

tryReleaseShared(int)//共享方式。尝试释放资源，成功则返回true，失败则返回false。

默认情况下，每个方法都抛出 UnsupportedOperationException 。  
这些方法的实现必须是内部线程安全的，并且

通常应该简短而不是阻塞。AQS类中的其他方法都是final  
，所以无法被其他类使用，只有这几个方法可以被其他类

使用。

以ReentrantLock为例，state初始化为0，表示未锁定状态。A线程lock()时，会调用tryAcquire()独占该锁并将

state+1。此后，其他线程再tryAcquire()时就会失败，直到A线程unlock()到state=0（即释放锁）为止，其它线程才

有机会获取该锁。当然，释放锁之前，A线程自己是可以重复获取此锁的（state会累加），这就是可重入的概念。但

要注意，获取多少次就要释放多么次，这样才能保证state是能回到零态的。

再以CountDownLatch以例，任务分为N个子线程去执行，state也初始化为N（注意N要与线程个数一致）。这N个

子线程是并行执行的，每个子线程执行完后countDown()一次，state会CAS(Compare and  
Swap)减1。等到所有子

线程都执行完后(即state=0)，会unpark()主调用线程，然后主调用线程就会从await()函数返回，继续后余动作。

一般来说，自定义同步器要么是独占方法，要么是共享方式，他们也只需实现  
tryAcquire-tryRelease 、tryAcquireShared-tryReleaseShared  
中的一种即可。但AQS也支持自定义同步器同时实现独占和共享两种方式，

如 ReentrantReadWriteLock 。

推荐两篇 AQS 原理和相关源码分析的文章：

[http://www.cnblogs.com/waterystone/p/4920797.html][http_www.cnblogs.com_waterystone_p_4920797.html]

[https://www.cnblogs.com/chengxiao/archive/2017/07/24/7141160.html][https_www.cnblogs.com_chengxiao_archive_2017_07_24_7141160.html]

##### 5.3 AQS 组件总结 #####

Semaphore(信号量)-允许多个线程同时访问： synchronized 和 ReentrantLock  
都是一次只允许一个线程访问

某个资源，Semaphore(信号量)可以指定多个线程同时访问某个资源。

CountDownLatch （倒计时器）：  
CountDownLatch是一个同步工具类，用来协调多个线程之间的同步。这个工具通常用来控制线程等待，它可以让某一个线程等待直到倒计时结束，再开始执行。

CyclicBarrier(循环栅栏)： CyclicBarrier 和 CountDownLatch  
非常类似，它也可以实现线程间的技术等待，但是它的功能比 CountDownLatch  
更加复杂和强大。主要应用场景和 CountDownLatch  
类似。CyclicBarrier的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。

CyclicBarrier默认的构造方法是 CyclicBarrier(int  
parties)，其参数表示屏障拦截的线程数量，每个线程调用await方法告诉 CyclicBarrier  
我已经到达了屏障，然后当前线程被阻塞。

关于AQS这部分的更多内容可以查看我的这篇文章:并发编程面试必备：AQS 原理以及 AQS  
同步组件总结

#### 写几个线程安全类，不安全的，支持排序的类名？【软通动力面试题】 ####

*  线程安全类：Vector、Hashtable、Stack。
 *  线程不安全的类：ArrayList、Linkedlist、HashSet、TreeSet、HashMap、TreeMap等。
 *  支持排序的类有HashSet、LinkedHashSet、TreeSet等（Set接口下的实现都支持排序）

此题主要考查集合框架的知识。在集合框架中Collection接口为集合的根类型，提供集合操作的常用API方法，该接口下派生出两个子接口，一个是不支持排序的List接口，一个是有自身排序的Set接口，所以回答排序与不排序分别从两接口的实现中在作答。线程安全上来说，Vector类比同属于List接口的ArrayList要早，是一个线程安全的类，在JDK1.2以后才推出一个异步的ArrayList类，比Vector类效率高。同理Stack继承自Vector也线程安全的类，另外在在Map接口的实现在Hashtable也是个线程安全的类。静态变量和实例变量的区别？

在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加,类中的成员变量也属于实例变量.

在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

例如，对于下面的程序，无论创建多少个实例对象，永远都只分配了一个staticVar变量，并且每创建一个实例对象，这个staticVar就会加1；但是，每创建一个实例对象，就会分配一个instanceVar，即可能分配多个instanceVar，并且每个instanceVar的值都只自加了1次。

publicclassVariantTest

publicstaticintstaticVar=0;

publicintinstanceVar=0;

publicVariantTest()

staticVar++;

instanceVar++;

System.out.println(“staticVar=”+staticVar+”,instanceVar=”+instanceVar);

备注：这个解答除了说清楚两者的区别外，最后还用一个具体的应用例子来说明两者的差异，体现了自己有很好的解说问题和设计案例的能力，思维敏捷，超过一般程序员，有写作能力！

#### 进程与线程的区别？ ####

> 答:进程是所有线程的集合，每一个线程是进程中的一条执行路径，线程只是一条执行路径。

#### 你在哪里用到了多线程？ ####

主要能体现到多线程提高程序效率、异步、GC线程、主线程、文件上传。

分批发送短信、迅雷多线程下载等。

#### 什么是多线程安全？ ####

要先谈到java内存模型，JMM。

当多个线程同时共享，同一个**全局变量或静态变量**，做写的操作时，可能会发生数据冲突问题，也就是线程安全问题。做读操作是不会发生数据冲突问题。

#### 说说线程安全问题 ####

线程安全是指要控制多个线程对某个资源的有序访问或修改，而在这些线程之间没有产生冲突。

在Java里，线程安全一般体现在两个方面：

1、多个thread对同一个java实例的访问（read和modify）不会相互干扰，它主要体现在关键字synchronized。如ArrayList和Vector，HashMap和Hashtable（后者每个方法前都有synchronized关键字）。如果你在interator一个List对象时，其它线程remove一个element，问题就出现了。

2、每个线程都有自己的字段，而不会在多个线程之间共享。它主要体现在java.lang.ThreadLocal类，而没有Java关键字支持，如像static、transient那样。

#### 如何解决多线程之间线程安全问题? ####

答:使用多线程之间同步或使用锁(lock)。

#### 为什么使用线程同步或使用锁能解决线程安全问题呢？ ####

答:将可能会发生数据冲突问题(线程不安全问题)，只能让当前一个线程进行执行。被包裹的代码执行完成后释放锁，让后才能让其他线程进行执行。这样的话就可以解决线程不安全问题。

#### 什么是多线程之间同步？ ####

答:当多个线程共享同一个资源,不会受到其他线程的干扰。

#### 什么是同步代码块？ ####

答:就是将可能会发生线程安全问题的代码，给包括起来。只能让当前一个线程进行执行，被包裹的代码执行完成之后才能释放所，让后才能让其他线程进行执行。

#### 多线程同步的分类？ ####

##### 使用同步代码块？ #####

**synchronized(同一个数据)\{**

**可能会发生线程冲突问题**

**\}**

<table> 
 <thead> 
  <tr> 
   <th>public void sale() { synchronized (mutex) { if (trainCount &gt; 0) { try { Thread.sleep(10); } catch (Exception e) { } System.out.println(Thread.currentThread().getName() + “,出售 第” + (100 - trainCount + 1) + “张票.”); trainCount–; } } }</th> 
  </tr> 
 </thead> 
 <tbody></tbody> 
</table>

##### 使用同步函数 #####

在方法上修饰synchronized 称为同步函数

<table> 
 <thead> 
  <tr> 
   <th>public synchronized void sale() { if (trainCount &gt; 0) { try { Thread.sleep(40); } catch (Exception e) { } System.out.println(Thread.currentThread().getName() + “,出售 第” + (100 - trainCount + 1) + “张票.”); trainCount–; } }</th> 
  </tr> 
 </thead> 
 <tbody></tbody> 
</table>

##### 静态同步函数 #####

方法上加上static关键字，使用synchronized 关键字修饰 为静态同步函数

静态的同步函数使用的锁是 该函数所属字节码文件对象

#### 同步代码块与同步函数区别？ ####

同步代码使用自定锁(明锁)

同步函数使用this锁

#### 什么是多线程死锁? ####

答：

同步中嵌套同步,无法释放锁的资源。

解决办法:同步中尽量不要嵌套同步

#### 同步函数与静态同步函数区别? ####

注意:有些面试会这样问：例如现在一个静态方法和一个非静态静态怎么实现同步？

同步函数使用this锁

静态同步函数使用字节码文件，也就是类.class

#### Condition用法 ####

Condition的功能类似于在传统的线程技术中的,Object.wait()和Object.notify()的功能,

**代码:**

<table> 
 <thead> 
  <tr> 
   <th>Condition condition = lock.newCondition(); res. condition.await(); 类似wait res. Condition. Signal() 类似notify <strong>Signalall notifyALL</strong></th> 
  </tr> 
 </thead> 
 <tbody></tbody> 
</table>

#### 如何停止线程？ ####

1.  使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。

2.   
使用stop方法强行终止线程（这个方法不推荐使用，因为stop和suspend、resume一样，也可能发生不可预料的结果）。

3.  使用interrupt方法中断线程。 线程在阻塞状态

#### 什么是守护线程 ####

Java中有两种线程，一种是用户线程，另一种是守护线程。

当进程不存在或主线程停止，守护线程也会被停止。

用setDaemon(true)方法设置为守护线程

#### join()方法作用 ####

join作用是让其他线程变为等待，只有当前线程执行完毕后，等待的线程才会被释放。

#### 线程三大特性 ####

多线程有三大特性，原子性、可见性、有序性

原子性:保证数据一致性，线程安全。

可见性:对另一个线程是否课件

有序性:线程之间执行有顺序

#### 线程之间怎么通讯 ####

wait方法，让当前线程上完锁之后进行等待。

notify ，拿到锁之后唤醒。

#### 线程的调度过程 ####

a.当线程池小于corePoolSize时，新提交的任务会创建一个新的线程执行，技术此线程池中有空闲线程。

b．当线程池达到corePoolSize时，新提交的任务将被放入workQueue，等待线程池中的任务调度执行。

c．当workQueue已满，并且maximunPoolSize>corePoolSize时，新提交的任务会创建新的线程执行。

d、当提交的任务书超过maximunPoolSize时，新提交的任务被拒绝；

e、当线程池中超过corePoolSize线程，空闲时间达到keepAliveTime时，关闭空闲线程。

f．当线程池中设置allowCoreThreadTimeOut=true时，线程池中corePoolSize线程超过keepAliveTime时也将被关闭。

#### 说说Java内存模型 ####

共享内存模型指的就是Java内存模型(简称JMM)，JMM决定一个线程对共享变量的写入时,能对另一个线程可见。从抽象的角度来看，JMM定义了线程和主内存之间的抽象关系：线程之间的共享变量存储在主内存（main  
memory）中，每个线程都有一个私有的本地内存（local  
memory），本地内存中存储了该线程以读/写共享变量的副本。本地内存是JMM的一个抽象概念，并不真实存在。它涵盖了缓存，写缓冲区，寄存器以及其他的硬件和编译器优化。

![F:\\每特教育\\教案\\课程\\0004-每特教育(蚂蚁课堂)-Java并发编程\\图片\\Java内存模型.png][Image 1]

#### ★什么是Volatile作用 ####

Volatile 关键字的作用 是变量在多个线程之间可见。

#### 什么是AtomicInteger ####

AtomicInteger原子类

#### ThreadLocal原理分析 ####

map集合

[Java并发编程：深入剖析ThreadLocal][Java_ThreadLocal]

#### 线程池作用 ####

基于以下几个原因在多线程应用程序中使用线程是必须的：

线程池改进了一个应用程序的响应时间。由于线程池中的线程已经准备好且等待被分配任务，应用程序可以直接拿来使用而不用新建一个线程。

1.  线程池节省了CLR  
    为每个短生存周期任务创建一个完整的线程的开销并可以在任务完成后回收资源。
2.  线程池根据当前在系统中运行的进程来优化线程时间片。
3.  线程池允许我们开启多个任务而不用为每个线程设置属性。
4.  线程池允许我们为正在执行的任务的程序参数传递一个包含状态信息的对象引用。
5.  线程池可以用来解决处理一个特定请求最大线程数量限制问题。

#### 说说JDK1.5并发包 ####

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Lock</td> 
   <td>锁</td> 
  </tr> 
  <tr> 
   <td>Executors</td> 
   <td>线程池</td> 
  </tr> 
  <tr> 
   <td>ReentrantLock</td> 
   <td>一个可重入的互斥锁定 Lock，功能类似synchronized，但要强大的多。</td> 
  </tr> 
  <tr> 
   <td>Condition</td> 
   <td>Condition的功能类似于在传统的线程技术中的,Object.wait()和Object.notify()的功能,</td> 
  </tr> 
  <tr> 
   <td>ConcurrentHashMap</td> 
   <td>分段HasMap</td> 
  </tr> 
  <tr> 
   <td>AtomicInteger</td> 
   <td>原子类</td> 
  </tr> 
  <tr> 
   <td>BlockingQueue</td> 
   <td>BlockingQueue 通常用于一个线程生产对象，而另外一个线程消费这些对象的场景</td> 
  </tr> 
  <tr> 
   <td>ExecutorService</td> 
   <td>执行器服务</td> 
  </tr> 
 </tbody> 
</table>

#### 锁的种类 ####

##### 分布式锁 #####

##### 自旋锁 #####

自旋锁是采用让当前线程不停地的在循环体内执行实现的，当循环的条件被其他线程改变时  
才能进入临界区。如下

<table> 
 <thead> 
  <tr> 
   <th>import java.util.concurrent.atomic.AtomicReference; public class SpinLock { private AtomicReference&lt;Thread&gt; sign = new AtomicReference&lt;&gt;(); public void lock() { Thread current = Thread.currentThread(); while (!sign.compareAndSet(null, current)) { } } public void unlock() { Thread current = Thread.currentThread(); sign.compareAndSet(current, null); } }</th> 
  </tr> 
 </thead> 
 <tbody></tbody> 
</table>

##### 互斥锁 #####

所谓互斥锁, 指的是一次最多只能有一个线程持有的锁. 在jdk1.5之前,  
我们通常使用synchronized机制控制多个线程对共享资源**Lock接口及其实现类ReentrantLock**

##### 可重入锁 #####

可重入锁，也叫做递归锁，指的是同一线程 外层函数获得锁之后  
，内层递归函数仍然有获取该锁的代码，但不受影响。

在JAVA环境下 ReentrantLock 和synchronized 都是 可重入锁

##### 悲观锁 #####

悲观锁，正如其名，它指的是对数据被外界（包括本系统当前的其他事务，以及来自外部系统的事务处理）修改持保守态度，因此，在整个数据处理过程中，将数据处于锁定状态。悲观锁的实现，往往依靠数据库提供的锁机制（也只有数据库层提供的锁机制才能真正保证数据访问的排他性，否则，即使在本系统中实现了加锁机制，也无法保证外部系统不会修改数据）。

##### 乐观锁 #####

相对悲观锁而言，乐观锁机制采取了更加宽松的加锁机制。悲观锁大多数情况下依靠数据库的锁机制实现，以保证操作最大程度的独占性。但随之而来的就是数据库  
性能的大量开销，特别是对长事务而言，这样的开销往往无法承受。  
而乐观锁机制在一定程度上解决了这个问题。乐观锁，大多是基于数据版本（ Version  
）记录机制实现。何谓数据版本？即为数据增加一个版本标识，在基于数据库表的版本解决方案中，一般是通过为数据库表增加一个  
“version”  
字段来实现。读取出数据时，将此版本号一同读出，之后更新时，对此版本号加一。此时，将提交数据的版本数据与数据库表对应记录的当前版本信息进行比对，如  
果提交的数据版本号大于数据库表当前版本号，则予以更新，否则认为是过期数据。

##### CAS乐观锁 #####

乐观锁是一种思想，即认为读多写少，遇到并发写的可能性比较低，所以采取在写时先读出当前版本号，然后加锁操作（比较跟上一次的版本号，如果一样则更新），如果失败则要重复读-比较-写的操作。

CAS是一种更新的原子操作，比较当前值跟传入值是否一样，一样则更新，否则失败。

CAS顶多算是乐观锁写那一步操作的一种实现方式罢了，不用CAS自己加锁也是可以的。

##### 悲观锁乐观锁 #####

乐观锁悲观锁

是一种思想。可以用在很多方面。

比如数据库方面。

悲观锁就是forupdate（锁定查询的行）

乐观锁就是version字段（比较跟上一次的版本号，如果一样则更新，如果失败则要重复读-比较-写的操作。）

JDK方面：

悲观锁就是sync

乐观锁就是原子类（内部使用CAS实现）

本质来说，就是悲观锁认为总会有人抢我的。

乐观锁就认为，基本没人抢。

#### 信号量 ####

信号量(Semaphore)，有时被称为信号灯，是在多线程环境下使用的一种设施,  
它负责协调各个线程, 以保证它们能够正确、合理的使用公共资源。

#### 同步和异步有何异同 ####

同步(synchronized)和异步(asynchronized)是对于多线程(multi-threading)而言的

同步可防止并发主要出于数据安全的考虑

如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。

异步允许并发

ajax技术通常都是异步实现的，异步主要使用在当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。

#### STOP()和SUSPEND()不推荐使用的原因？ ####

**stop()是因为它不安全。它会解除由线程获取的所有锁定，当在一个线程对象上调用stop()方法时，这个线程对象所运行的线程就会立即停止**，假如一个线程正在执行：synchronizedvoid\{x=3;y=4;\}　由于方法是同步的，多个线程访问时总能保证x,y被同时赋值，而如果一个线程正在执行到x=3;时，被调用了stop()方法，即使在同步块中，它也干脆地stop了，这样就产生了不完整的残废数据。而多线程编程中最最基础的条件要保证数据的完整性，所以请忘记线程的stop方法，以后我们再也不要说“停止线程”了。而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。

\*\*suspend()方法容易发生死锁。调用suspend()的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。\*\*此时，其他任何线程都不能访问锁定的资源，除非被"挂起"的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。所以不应该使用suspend()，而应在自己的Thread类中置入一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，便用wait()命其进入等待状态。若标志指出线程应当恢复，则用一个notify()重新启动线程。

#### 实现Runnable接口和Callable接口的区别 ####

如果想让线程池执行任务的需要实现Runnable接口或者Callable接口。

Runnable接口或Callable接口都可以被ThreadPoolEexcutor或者ScheduledThreadPoolExecutor执行。

两者的区别在于Runable接口不会返回结果。

备注：工具类Executors可以实现Runable独享和Callable对象之间的相互转换。（Executors.callable（Runable  
task）或Executors.callable(Runable task,Object resule)）

执行execute方法和submit方法的区别

方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功与否。

#### 讲一下java 的内存模型 ####

在 JDK1.2  
之前，Java的内存模型实现总是从主存（即共享内存）读取变量，是不需要进行特别的注意的。而在当前的  
Java  
内存模型下，线程可以把变量保存本地内存（比如机器的寄存器）中，而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一个变量的值，而另外一个线程还继续使用它在寄存器中的变量值的拷贝，造成数据的不一致。

![Image 1][]

要解决这个问题，就需要把变量声明为 volatile，这就指示  
JVM，这个变量是不稳定的，每次使用它都到主存中进行读取。

说白了， volatile  
关键字的主要作用就是保证变量的可见性然后还有一个作用是防止指令重排序。

![Image 1][]

#### 什么是ThreadLocal ####

ThreadLocal提高一个线程的局部变量，访问某个线程拥有自己局部变量。

当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。

ThreadLocal的接口方法

ThreadLocal类接口很简单，只有4个方法，我们先来了解一下：

void set(Object value)设置当前线程的线程局部变量的值。

public Object get()该方法返回当前线程所对应的线程局部变量。

public void  
remove()将当前线程局部变量的值删除，目的是为了减少内存的占用，该方法是JDK  
5.0新增的方法。需要指出的是，当线程结束后，对应该线程的局部变量将自动被垃圾回收，所以显式调用该方法清除线程的局部变量并不是必须的操作，但它可以加快内存回收的速度。

protected Object  
initialValue()返回该线程局部变量的初始值，该方法是一个protected的方法，显然是为了让子类覆盖而设计的。这个方法是一个延迟调用方法，在线程第1次调用get()或set(Object)时才执行，并且仅执行1次。ThreadLocal中的缺省实现直接返回一个null。

#### Tread和Threadlocal的作用及区别？ ####

threadlocal是线程局部变量（threadlocalvariable），为每一个使用该线程的线程都提供一个变量值的副本，使每一个线程都可以独立地改变自己的副本，而不会和其他线程的副本产生冲突。

#### sleep()、join（）、yield（）有什么区别 ####

1、sleep()方法

在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。让其他线程有机会继续执行，但它并不释放对象锁。也就是如果有Synchronized同步块，其他线程仍然不能访问共享数据。注意该方法要捕获异常

比如有两个线程同时执行(没有Synchronized)，一个线程优先级为MAX\_PRIORITY，另一个为MIN\_PRIORITY，如果没有Sleep()方法，只有高优先级的线程执行完成后，低优先级的线程才能执行；但当高优先级的线程sleep(5000)后，低优先级就有机会执行了。

总之，sleep()可以使低优先级的线程得到执行的机会，当然也可以让同优先级、高优先级的线程有执行的机会。

2、yield()方法

yield()方法和sleep()方法类似，也不会释放“锁标志”，区别在于，它没有参数，即yield()方法只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行，另外yield()方法只能使同优先级或者高优先级的线程得到执行机会，这也和sleep()方法不同。

3、join()方法

Thread的非静态方法join()让一个线程B“加入”到另外一个线程A的尾部。在A执行完毕之前，B不能工作。

Threadt=newMyThread();t.start();t.join();

保证当前线程停止执行，直到该线程所加入的线程完成为止。然而，如果它加入的线程没有存活，则当前线程不需要停止。

#### 说说CountDownLatch原理 ####

参考：

[分析CountDownLatch的实现原理][CountDownLatch]

[什么时候使用CountDownLatch][CountDownLatch 1]

[Java并发编程：CountDownLatch、CyclicBarrier和Semaphore][Java_CountDownLatch_CyclicBarrier_Semaphore]

#### 说说CyclicBarrier原理 ####

参考：

[JUC回顾之-CyclicBarrier底层实现和原理][JUC_-CyclicBarrier]

#### 说说Semaphore原理 ####

[JAVA多线程–信号量(Semaphore)][JAVA_Semaphore]

[JUC回顾之-Semaphore底层实现和原理][JUC_-Semaphore]

#### 说说Exchanger原理 ####

[java.util.concurrent.Exchanger应用范例与原理浅析][java.util.concurrent.Exchanger]

#### 说说CountDownLatch与CyclicBarrier区别 ####

![https://upload-images.jianshu.io/upload\_images/1807893-2fa6aa5d1bff6c88.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/700][Image 1]

[尽量把CyclicBarrier和CountDownLatch的区别说通俗点][CyclicBarrier_CountDownLatch]

#### 线程的生命周期 ####

**新建**(New)、**就绪**（Runnable）、**运行**（Running）、**阻塞**(Blocked)和**死亡**(Dead)**5种状态**

(1)生命周期的五种状态

**新建（newThread）**

当创建Thread类的一个实例（对象）时，此线程进入新建状态（未被启动）。

例如：Threadt1=newThread();

**就绪（runnable）**

线程已经被启动，正在等待被分配给CPU时间片，也就是说此时线程正在就绪队列中排队等候得到CPU资源。例如：**t1.start();**

**运行（running）**

线程获得CPU资源正在执行任务（run()方法），此时除非此线程自动放弃CPU资源或者有优先级更高的线程进入，线程将一直运行到结束。

**死亡（dead）**

当线程执行完毕或被其它线程杀死，线程就进入死亡状态，这时线程不可能再进入就绪状态等待执行。

自然终止：正常运行run()方法后终止

异常终止：调用\*\*stop()\*\*方法让一个线程终止运行

**堵塞（blocked）**

由于某种原因导致正在运行的线程让出CPU并暂停自己的执行，即进入堵塞状态。

正在睡眠：用sleep(longt)方法可使线程进入睡眠方式。一个睡眠着的线程在指定的时间过去可进入就绪状态。

正在等待：调用wait()方法。（调用motify()方法回到就绪状态）

被另一个线程所阻塞：调用suspend()方法。（调用resume()方法恢复）

参考：

[线程的生命周期][Link 2]

#### 锁机制 ####

#### volatile实现原理 ####

[聊聊并发（一）——深入分析Volatile的实现原理][Volatile]

#### ABA问题 ####

ABA：如果另一个线程修改V值假设原来是A，先修改成B，再修改回成A，当前线程的CAS操作无法分辨当前V值是否发生过变化。

参考：

[JavaCAS和ABA问题][JavaCAS_ABA]

#### 乐观锁的业务场景及实现方式 ####

乐观锁（OptimisticLock）：

每次获取数据的时候，都不会担心数据被修改，所以每次获取数据的时候都不会进行加锁，但是在更新数据的时候需要判断该数据是否被别人修改过。如果数据被其他线程修改，则不进行数据更新，如果数据没有被其他线程修改，则进行数据更新。由于数据没有进行加锁，期间该数据可以被其他线程进行读写操作。

乐观锁：比较适合读取操作比较频繁的场景，如果出现大量的写入操作，数据发生冲突的可能性就会增大，为了保证数据的一致性，应用层需要不断的重新获取数据，这样会增加大量的查询操作，降低了系统的吞吐量。

#### 线程的基本概念、线程的基本状态以及状态之间的关系 ####

一个程序中可以有多条执行线索同时执行，一个线程就是程序中的一条执行线索，每个线程上都关联有要执行的代码，即可以有多段程序代码同时运行，每个程序至少都有一个线程，即main方法执行的那个线程。如果只是一个cpu，它怎么能够同时执行多段程序呢？这是从宏观上来看的，cpu一会执行a线索，一会执行b线索，切换时间很快，给人的感觉是a,b在同时执行，好比大家在同一个办公室上网，只有一条链接到外部网线，其实，这条网线一会为a传数据，一会为b传数据，由于切换时间很短暂，所以，大家感觉都在同时上网。

状态：就绪，运行，synchronize阻塞，wait和sleep挂起，结束。wait必须在synchronized内部调用。

调用线程的start方法后线程进入就绪状态，线程调度系统将就绪状态的线程转为运行状态，遇到synchronized语句时，由运行状态转为阻塞，当synchronized获得锁后，由阻塞转为运行，在这种情况可以调用wait方法转为挂起状态，当线程关联的代码执行完后，线程变为结束状态。

#### 同步和异步有何异同，在什么情况下分别使用他们？举例说明。（参考105题答案） ####

当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。

#### 当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法？ ####

分几种情况：

> 1.其他方法前是否加了synchronized关键字，如果没加，则能。

> 2.如果这个方法内部调用了wait，则可以进入其他synchronized方法。

> 3.如果其他个方法都加了synchronized关键字，并且内部没有调用wait，则不能。

> 4.如果其他方法是static，它用的同步锁是当前类的字节码，与非静态的方法不能同步，因为非静态的方法用的是this。

[Image 1]: 
[Java]: https://link.jianshu.com/?t=http%3A%2F%2Fwww.cnblogs.com%2Fdolphin0520%2Fp%2F3932921.html
[Link 1]: https://link.jianshu.com/?t=http%3A%2F%2Fblog.csdn.net%2Fcyantide%2Farticle%2Fdetails%2F50880211
[http_www.cnblogs.com_waterystone_p_4920797.html]: http://www.cnblogs.com/waterystone/p/4920797.html
[https_www.cnblogs.com_chengxiao_archive_2017_07_24_7141160.html]: https://www.cnblogs.com/chengxiao/archive/2017/07/24/7141160.html
[Java_ThreadLocal]: https://link.jianshu.com/?t=https%3A%2F%2Fwww.cnblogs.com%2Fdolphin0520%2Fp%2F3920407.html
[CountDownLatch]: https://www.jianshu.com/p/7c7a5df5bda6?ref=myread
[CountDownLatch 1]: https://link.jianshu.com/?t=http%3A%2F%2Fwww.importnew.com%2F15731.html
[Java_CountDownLatch_CyclicBarrier_Semaphore]: https://link.jianshu.com/?t=http%3A%2F%2Fwww.cnblogs.com%2Fdolphin0520%2Fp%2F3920397.html
[JUC_-CyclicBarrier]: https://link.jianshu.com/?t=http%3A%2F%2Fwww.cnblogs.com%2F200911%2Fp%2F6060195.html
[JAVA_Semaphore]: https://link.jianshu.com/?t=https%3A%2F%2Fmy.oschina.net%2Fcloudcoder%2Fblog%2F362974
[JUC_-Semaphore]: https://link.jianshu.com/?t=https%3A%2F%2Fwww.cnblogs.com%2F200911%2Fp%2F6060359.html
[java.util.concurrent.Exchanger]: https://link.jianshu.com/?t=http%3A%2F%2Flixuanbin.iteye.com%2Fblog%2F2166772
[CyclicBarrier_CountDownLatch]: https://link.jianshu.com/?t=http%3A%2F%2Faaron-han.iteye.com%2Fblog%2F1591755
[Link 2]: https://link.jianshu.com/?t=https%3A%2F%2Fwww.cnblogs.com%2Flangjunnan%2Fp%2F6444718.html
[Volatile]: https://link.jianshu.com/?t=http%3A%2F%2Fwww.infoq.com%2Fcn%2Farticles%2Fftf-java-volatile
[JavaCAS_ABA]: https://link.jianshu.com/?t=https%3A%2F%2Fwww.cnblogs.com%2F549294286%2Fp%2F3766717.html