面试知识点三：Java多线程
35.并行和并发有什么区别？
36.线程和进程的区别？
37.守护线程是什么？
38.创建线程有哪几种方式？
39.说一下 runnable 和 callable 有什么区别？
40.线程有哪些状态？
41.sleep() 和 wait() 有什么区别？
42.notify()和 notifyAll()有什么区别？
43.线程的 run()和 start()有什么区别？
44.创建线程池有哪几种方式？
45.线程池都有哪些状态？
46.线程池中 submit()和 execute()方法有什么区别？
47.在 java 程序中怎么保证多线程的运行安全？
48.多线程锁的升级原理是什么？
49.什么是死锁？
50.怎么防止死锁？
51.ThreadLocal 是什么？有哪些使用场景？
52.说一下 synchronized 底层实现原理？
53.synchronized 和 volatile 的区别是什么？
54.synchronized 和 Lock 有什么区别？
55.synchronized 和 ReentrantLock 区别是什么？
56.说一下 atomic 的原理？
35.并发和并行有什么区别？
1、并发（concurrency）：指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干片，使多个进程快速交替的执行。
如上图所示，并发就是只有一个CPU资源，程序（或线程）之间要竞争得到执行机会。图中的第一个阶段，在A执行的过程中，B、C不会执行，因为这段时间内这个CPU资源被A竞争到了，同理，第二阶段只有B在执行，第三阶段只有C在执行。其实，并发过程中，A、B、C并不是同时进行的（微观角度），但又是同时进行的（宏观角度）。
2、并行（parallellism）:指在同一时刻，有多条指令在多个处理器上同时执行
如图所示，在同一时刻，ABC都是同时执行（微观、宏观）
通过多线程实现并发，并行：
➤ java中的Thread类定义了多线程，通过多线程可以实现并发或并行。
➤ 在CPU比较繁忙，资源不足的时候（开启了很多进程），操作系统只为一个含有多线程的进程分配仅有的CPU资源，这些线程就会为自己尽量多抢时间片，这就是通过多线程实现并发，线程之间会竞争CPU资源争取执行机会。
➤ 在CPU资源比较充足的时候，一个进程内的多线程，可以被分配到不同的CPU资源，这就是通过多线程实现并行。
➤ 至于多线程实现的是并发还是并行？上面所说，所写多线程可能被分配到一个CPU内核中执行，也可能被分配到不同CPU执行，分配过程是操作系统所为，不可人为控制。所以，如果有人问我我所写的多线程是并发还是并行的？我会说，都有可能。
➤ 不管并发还是并行，都提高了程序对CPU资源的利用率，最大限度地利用CPU资源
36.线程和进程的区别？
线程具有许多传统进程所具有的特征，故又称为轻型进程(Light—Weight Process)或进程元；而把传统的进程称为重型进程(Heavy—Weight Process)，它相当于只有一个线程的任务。在引入了线程的操作系统中，通常一个进程都有若干个线程，至少需要一个线程。下面，我们从调度、并发性、 系统开销、拥有资源等方面，来比较线程与进程。
1．调度
在传统的操作系统中，拥有资源的基本单位和独立调度、分派的基本单位都是进程。而在引入线程的操作系统中，则把线程作为调度和分派的基本单位。而把进程作为资源拥有的基本单位，使传统进程的两个属性分开，线程便能轻装运行，从而可显著地提高系统的并发程度。在同一进程中，线程的切换不会引起进程的切换，在由一个进程中的线程切换到另一个进程中的线程时，将会引起进程的切换。
2．并发性
在引入线程的操作系统中，不仅进程之间可以并发执行，而且在一个进程中的多个线程之间，亦可并发执行，因而使操作系统具有更好的并发性，从而能更有效地使用系统资源和提高系统吞吐量。例如，在一个未引入线程的单CPU操作系统中，若仅设置一个文件服务进程，当它由于某种原因而被阻塞时，便没有其它的文件服务进程来提供服务。在引入了线程的操作系统中，可以在一个文件服务进程中，设置多个服务线程，当第一个线程等待时，文件服务进程中的第二个线程可以继续运行；当第二个线程阻塞时，第三个线程可以继续执行，从而显著地提高了文件服务的质量以及系统吞吐量。
3．拥有资源
不论是传统的操作系统，还是设有线程的操作系统，进程都是拥有资源的一个独立单位，它可以拥有自己的资源。一般地说，线程自己不拥有系统资源(也有一点必不可少的资源)，但它可以访问其隶属进程的资源。亦即，一个进程的代码段、数据段以及系统资源，如已打开的文件、I/O设备等，可供同一进程的其它所有线程共享。
4．系统开销
由于在创建或撤消进程时，系统都要为之分配或回收资源，如内存空间、I／O设备等。因此，操作系统所付出的开销将显著地大于在创建或撤消线程时的开销。类似地，在进行进程切换时，涉及到整个当前进程CPU环境的保存以及新被调度运行的进程的CPU环境的设置。而线程切换只须保存和设置少量寄存器的内容，并不涉及存储器管理方面的操作。可见，进程切换的开销也远大于线程切换的开销。此外，由于同一进程中的多个线程具有相同的地址空间，致使它们之间的同步和通信的实现，也变得比较容易。在有的系统中，线程的切换、同步和通信都无须操作系统内核的干预 。
37.守护线程是什么？
守护线程（即daemon thread），是个服务线程，准确地来说就是服务其他的线程，这是它的作用。而其他的线程只有一种，那就是用户线程。所以java里线程分2种，
public class Thread01 extends Thread { @Override public void run() { for (int i = 0; i < 100; i++) { System.out.println(i); } } }
测试一下，将thread设置成守护线程：
public class test { public static void main(String[] args) { Thread thread = new Thread01(); thread.setDaemon(true); thread.start(); } }
结果可能是如下一种，也可能什么都不打印
0
1
2
3
thread被设置成守护线程，那么用户线程是main线程，当main线程执行完了之后，JVM退出，守护线程thread也就不再执行。
38.创建线程有哪几种方式？
三种
1、继承Thread类，重写父类的run()方法
2、实现Runnable接口，重写run()方法，通过其实现类使用Thread
3、实现Callable接口，重写call()方法，通过Runnable实现类使用Thread
39.说一下 runnable 和 callable 有什么区别？
1、Runnable没有返回值；Callable可以返回执行结果，是个泛型，和Future、FutureTask配合可以用来获取异步执行的结果
2、Callable接口的call()方法允许抛出异常；Runnable的run()方法异常只能在内部消化，不能往上继续抛
注：Callalbe接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。
Runnable接口：
public interface Runnable { public abstract void run(); }
Callable接口：
public interface Callable<V> { V call() throws Exception; }
40.线程有哪些状态？
虚拟机中的线程状态有六种，定义在Thread.State中：
public enum State { /** * Thread state for a thread which has not yet started. */ NEW, /** * Thread state for a runnable thread. A thread in the runnable * state is executing in the Java virtual machine but it may * be waiting for other resources from the operating system * such as processor. */ RUNNABLE, /** * Thread state for a thread blocked waiting for a monitor lock. * A thread in the blocked state is waiting for a monitor lock * to enter a synchronized block/method or * reenter a synchronized block/method after calling * {@link Object#wait() Object.wait}. */ BLOCKED, /** * Thread state for a waiting thread. * A thread is in the waiting state due to calling one of the * following methods: * <ul> * <li>{@link Object#wait() Object.wait} with no timeout</li> * <li>{@link #join() Thread.join} with no timeout</li> * <li>{@link LockSupport#park() LockSupport.park}</li> * </ul> * * <p>A thread in the waiting state is waiting for another thread to * perform a particular action. * * For example, a thread that has called <tt>Object.wait()</tt> * on an object is waiting for another thread to call * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on * that object. A thread that has called <tt>Thread.join()</tt> * is waiting for a specified thread to terminate. */ WAITING, /** * Thread state for a waiting thread with a specified waiting time. * A thread is in the timed waiting state due to calling one of * the following methods with a specified positive waiting time: * <ul> * <li>{@link #sleep Thread.sleep}</li> * <li>{@link Object#wait(long) Object.wait} with timeout</li> * <li>{@link #join(long) Thread.join} with timeout</li> * <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li> * <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li> * </ul> */ TIMED_WAITING, /** * Thread state for a terminated thread. * The thread has completed execution. */ TERMINATED; }
1、New：新建状态
当线程实例被new出来之后，调用start()方法之前，线程实例处于新建状态。比如"Thread thread = new Thread()"，thread就是一个处于NEW状态的线程。
2、Runnable：可运行状态
new出来线程，调用start()方法即处于Runnable状态了。处于Runnable状态的线程可能正在Java虚拟机中运行，也可能正在等待处理器的资源，因为一个线程必须获得CPU的资源后，才可以运行其run()方法中的内容，否则排队等待。
3、Blocked：阻塞状态
如果某一线程正在等待监视器锁，以便进入一个同步的块/方法，那么这个线程的状态就是阻塞Bloked。
4、Waiting：等待状态
某一线程因为调用不带超时的Object的wait()方法、不带超时的Thread的join()方法、LockSupport的park()方法，就会处于等待Waiting状态，等待被其它线程唤醒。
5、Timed_Waiting：超时等待状态
某一线程因为调用带有指定正等待时间（即传入时间参数）的Object的wait()方法、Thread的join()方法、Thread的sleep()方法、LockSupport的parkNanos()方法、LockSupport的parkUntil()方法，就会处于超时等待Timed_Waiting状态。
6、Terminated：中止状态
线程调用终止或者run()方法执行结束后，线程即处于终止状态。处于终止状态的线程不具备继续运行的能力。
线程的转换状态
上面也提到了，某一时间点线程的状态只能是上述6个状态中的其中一个；但是，线程在程序运行过程中的状态是会发生变化的，由一个状态转变为另一个状态，那么下面给出线程状态转换图帮助我们清晰地理解线程的状态转变过程：
41.sleep() 和 wait() 有什么区别？
1、这两个方法来自不同的类，sleep来自Thread类，而wait来自Object类。
2、sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
3、使用范围：wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用
42.notify()和 notifyAll()有什么区别？
假设一个线程A调用了某个对象的wait()方法，线程A就会释放该对象的锁(因为wait()方法必须出现在synchronized中，这样自然在执行wait()方法之前线程A就已经拥有了该对象的锁)，同时线程A就进入到了该对象的等待池中。
如果另外的一个线程调用了相同对象的notifyAll()方法，那么处于该对象的等待池中的线程就会全部进入该对象的锁池中，准备争夺锁的拥有权。
如果另外的一个线程调用了相同对象的notify()方法，那么仅仅有一个处于该对象的等待池中的线程(随机)会进入该对象的锁池.
43.线程的 run()和 start()有什么区别？
线程通过调用start方法启动，然后执行run()方法中的内容，使用start方法才真正实现了多线程运行，因为这个时候不用等待我们的run方法执行完成就可以继续执行下面的代码，这才叫多线程嘛！
直接使用thread执行run方法呢？因为run方法是thread里面的一个普通的方法，所以我们直接调用run方法，这个时候它是会运行在我们的主线程中的，因为这个时候我们的程序中只有主线程一个线程，那么他们的执行顺序一定是顺序执行，所以这样并没有做到多线程的这种目的。
44.创建线程池有哪几种方式？
1、newSingleThreadExecutor()
创建一个单线程化的Executor，即只创建唯一的工作线程来执行任务，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO,优先级)执行。如果这个线程异常结束，会有另一个取代它，保证顺序执行。单工作线程最大的特点是可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。
2、newFixedThreadPool(int nThreads)
创建一个指定工作线程数量的线程池。每当提交一个任务就创建一个工作线程，如果工作线程数量达到线程池初始的最大数，则将提交的任务存入到池队列中。FixedThreadPool是一个典型且优秀的线程池，它具有线程池提高程序效率和节省创建线程时所耗的开销的优点。但是，在线程池空闲时，即线程池中没有可运行任务时，它不会释放工作线程，还会占用一定的系统资源。
3、newCachedThreadPool()
创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
这种类型的线程池特点是：
- 工作线程的创建数量几乎没有限制(其实也有限制的,数目为Interger. MAX_VALUE), 这样可灵活的往线程池中添加线程。
- 如果长时间没有往线程池中提交任务，即如果工作线程空闲了指定的时间(默认为1分钟)，则该工作线程将自动终止。终止后，如果你又提交了新的任务，则线程池重新创建一个工作线程。
- 在使用CachedThreadPool时，一定要注意控制任务的数量，否则，由于大量线程同时运行，很有会造成系统瘫痪。
4、newScheduledThreadPool(int corePoolSize)
创建一个定长的线程池，而且支持定时的以及周期性的任务执行
45.线程池都有哪些状态？
线程池的五种状态：
1、RUNNING
(1) 状态说明：线程池处在RUNNING状态时，能够接收新任务，以及对已添加的任务进行处理。
(02) 状态切换：线程池的初始化状态是RUNNING。换句话说，线程池被一旦被创建，就处于RUNNING状态，并且线程池中的任务数为0！
2、 SHUTDOWN
(1) 状态说明：线程池处在SHUTDOWN状态时，不接收新任务，但能处理已添加的任务。
(2) 状态切换：调用线程池的shutdown()接口时，线程池由RUNNING -> SHUTDOWN。
3、STOP
(1) 状态说明：线程池处在STOP状态时，不接收新任务，不处理已添加的任务，并且会中断正在处理的任务。
(2) 状态切换：调用线程池的shutdownNow()接口时，线程池由(RUNNING or SHUTDOWN ) -> STOP。
4、TIDYING
(1) 状态说明：当所有的任务已终止，ctl记录的”workerCount”为0，线程池会变为TIDYING状态。当线程池变为TIDYING状态时，会执行钩子函数terminated()。terminated()在ThreadPoolExecutor类中是空的，若用户想在线程池变为TIDYING时，进行相应的处理；可以通过重载terminated()函数来实现。
(2) 状态切换：当线程池在SHUTDOWN状态下，阻塞队列为空并且线程池中执行的任务也为空时，就会由 SHUTDOWN -> TIDYING。
当线程池在STOP状态下，线程池中执行的任务为空时，就会由STOP -> TIDYING。
5、 TERMINATED
(1) 状态说明：线程池彻底终止，就变成TERMINATED状态。
(2) 状态切换：线程池处在TIDYING状态时，执行完terminated()之后，就会由 TIDYING -> TERMINATED。
46.线程池中 submit()和 execute()方法有什么区别？
先看一下ExecutorService接口定义的三种submit方法
1、Future<T> submit(Callable<T> task)
public class test { public static void main(String[] args) { ExecutorService executorService = Executors.newFixedThreadPool(5); List<Future<String>> list = new ArrayList<>(); for (int i = 0; i < 5; i++) { Future<String> submit = executorService.submit(new Callable<String>() { @Override public String call() throws Exception { return "call方法返回字符串"; } }); list.add(submit); } try { Thread.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("返回结果list的size====" + list.size()); for (Future<String> stringFuture : list) { try { String s = stringFuture.get(); System.out.println("返回结果====" + s); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } } executorService.shutdown(); } }
结果：
返回结果list的size====5 返回结果====call方法返回字符串 返回结果====call方法返回字符串 返回结果====call方法返回字符串 返回结果====call方法返回字符串 返回结果====call方法返回字符串
可以看到，Callable接口定义的call()方法是有返回值的，所以可以通过submit(Callable<T> task)的结果submit.get()获取返回值。
2、Future<?> submit(Runnable task);
public class test { public static void main(String[] args) { ExecutorService executorService = Executors.newFixedThreadPool(5); List<Future<?>> list = new ArrayList<>(); for (int i = 0; i < 5; i++) { final int num = i; Future<?> submit = executorService.submit(new Runnable() { @Override public void run() { System.out.println(num); } }); list.add(submit); } try { Thread.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("返回结果list的size====" + list.size()); for (Future<?> future : list) { boolean done = future.isDone(); System.out.println("执行是否成功===" + done); } executorService.shutdown(); } }
结果：
1 2 0 4 3 返回结果list的size====5 执行是否成功===true 执行是否成功===true 执行是否成功===true 执行是否成功===true 执行是否成功===true
可以看到，Runnable接口定义的run()方法是没有返回值的，但是可以通过submit(Callable<T> task)的结果submit.isDone()判断是否执行成功。
3、Future<T> submit(Runnable task, T result)
public class test { public static void main(String[] args) { ExecutorService executorService = Executors.newFixedThreadPool(5); List<Future<String>> list = new ArrayList<>(); for (int i = 0; i < 5; i++) { final int num = i; String s = "runnable的返回值"; Future<String> submit = executorService.submit(new Runnable() { @Override public void run() { System.out.println(num); } }, s); list.add(submit); } try { Thread.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("返回结果list的size====" + list.size()); for (Future<String> future : list) { String s = null; try { s = future.get(); System.out.println(s); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } } executorService.shutdown(); } }
结果：
0 2 4 3 1 返回结果list的size====5 runnable的返回值 runnable的返回值 runnable的返回值 runnable的返回值 runnable的返回值
可以看到，Runnable接口定义的run()方法是没有返回值的，但是submit()方法的第二个参数可以定义返回值。
关于以上三种submit是怎么执行的，参考：理解三种任务Runnable和Callable和FutureTask的用法
所以，submit()和 execute()方法有什么区别？
1、submit()方法是否返回值的，executor()方法是没有返回值的。
2、submit在执行过程中与execute不一样，不会抛出异常而是把异常保存在成员变量中，在FutureTask.get获取的时候再把异常抛出来。
3、execute直接抛出异常之后线程就死掉了，submit保存异常线程没有死掉，因此execute的线程池可能会出现没有意义的情况，因为线程没有得到重用。而submit不会出现这种情况。
后两个区别参考：并发编程之submit和execute区别（七）
47.在 java 程序中怎么保证多线程的运行安全？
线程安全在三个方面体现
1.原子性：提供互斥访问，同一时刻只能有一个线程对数据进行操作，（synchronized）；
synchronized是一种同步锁，通过锁实现原子操作。
JDK提供锁分两种：一种是synchronized，依赖JVM实现锁，因此在这个关键字作用对象的作用范围内是同一时刻只能有一个线程进行操作；另一种是LOCK，是JDK提供的代码层面的锁，依赖CPU指令，代表性的是ReentrantLock。
2.可见性：一个线程对主内存的修改可以及时地被其他线程看到，（volatile）；
volatile的可见性是通过内存屏障和禁止重排序实现的
volatile会在写操作时，会在写操作后加一条store屏障指令，将本地内存中的共享变量值刷新到主内存。
volatile在进行读操作时，会在读操作前加一条load指令，从内存中读取共享变量。
3.有序性：一个线程观察其他线程中的指令执行顺序，由于指令重排序，该观察结果一般杂乱无序，（happens-before原则）。
48.多线程锁的升级原理是什么？
在所有的锁都启用的情况下线程进入临界区时会先去获取偏向锁，如果已经存在偏向锁了，则会尝试获取轻量级锁，启用自旋锁，如果自旋也没有获取到锁，则使用重量级锁，没有获取到锁的线程阻塞挂起，直到持有锁的线程执行完同步块；
偏向锁是在无锁争用的情况下使用的，也就是在当前线程没有执行完之前，没有其它线程会执行该同步块，一旦有了第二个线程的争用，偏向锁就会升级为轻量级锁，如果轻量级锁自旋到达阈值后，没有获取到锁，就会升级为重量级锁；
如果线程争用激烈，那么应该禁用偏向锁。
49.什么是死锁？
简单的说，死锁就是线程1已经持有锁A，要去获取锁B，线程2已经持有锁B，要去获取锁A，即两个线程都在等待获取对方持有的锁。
图示：
50.怎么防止死锁？
1、让程序每次至多只能获得一个锁。当然，在多线程环境下，这种情况通常并不现实
2、设计时考虑清楚锁的顺序，尽量减少嵌在的加锁交互数量
3、既然死锁的产生是两个线程无限等待对方持有的锁，那么只要等待时间有个上限不就好了。当然synchronized不具备这个功能，但是我们可以使用Lock类中的tryLock方法去尝试获取锁，这个方法可以指定一个超时时限，在等待超过该时限之后便会返回一个失败信息。
51.ThreadLocal 是什么？有哪些使用场景？
ThreadLocal，很多地方叫做线程本地变量，也有些地方叫做线程本地存储，其实意思差不多。ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量。
ThreadLocal是如何为每个线程创建变量的副本的：
首先，在每个线程Thread内部有一个ThreadLocal.ThreadLocalMap类型的成员变量threadLocals，这个threadLocals就是用来存储实际的变量副本的，键值为当前ThreadLocal变量，value为变量副本（即T类型的变量）。
初始时，在Thread里面，threadLocals为空，当通过ThreadLocal变量调用get()方法或者set()方法，就会对Thread类中的threadLocals进行初始化，并且以当前ThreadLocal变量为键值，以ThreadLocal要保存的副本变量为value，存到threadLocals。
然后在当前线程里面，如果要使用副本变量，就可以通过get方法在threadLocals里面查找。
最常见的ThreadLocal使用场景为 用来解决 数据库连接、Session管理等。
private static ThreadLocal<Connection> connectionHolder = new ThreadLocal<Connection>() { public Connection initialValue() { return DriverManager.getConnection(DB_URL); } }; public static Connection getConnection() { return connectionHolder.get(); }
private static final ThreadLocal threadSession = new ThreadLocal(); public static Session getSession() throws InfrastructureException { Session s = (Session) threadSession.get(); try { if (s == null) { s = getSessionFactory().openSession(); threadSession.set(s); } } catch (HibernateException ex) { throw new InfrastructureException(ex); } return s; }
52.说一下 synchronized 底层实现原理？
从字节码中可知同步语句块的实现使用的是monitorenter 和 monitorexit 指令，其中monitorenter指令指向同步代码块的开始位置，monitorexit指令则指明同步代码块的结束位置，当执行monitorenter指令时，当前线程将试图获取 objectref(即对象锁) 所对应的 monitor 的持有权，当 objectref 的 monitor 的进入计数器为 0，那线程可以成功取得 monitor，并将计数器值设置为 1，取锁成功。如果当前线程已经拥有 objectref 的 monitor 的持有权，那它可以重入这个 monitor (关于重入性稍后会分析)，重入时计数器的值也会加 1。倘若其他线程已经拥有 objectref 的 monitor 的所有权，那当前线程将被阻塞，直到正在执行线程执行完毕，即monitorexit指令被执行，执行线程将释放 monitor(锁)并设置计数器值为0 ，其他线程将有机会持有 monitor 。
53.synchronized 和 volatile 的区别是什么？
- volatile本质是在告诉jvm当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取； synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。
- volatile仅能使用在变量级别；synchronized则可以使用在变量、方法、和类级别的
- volatile仅能实现变量的修改可见性，不能保证原子性；而synchronized则可以保证变量的修改可见性和原子性
- volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞。
- volatile标记的变量不会被编译器优化；synchronized标记的变量可以被编译器优化
synchronized和volatile的使用方法以及区别
54.synchronized 和 Lock 有什么区别？
1）Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；
2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；
3）Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；
4）通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。
5）Lock可以提高多个线程进行读操作的效率。
55.synchronized 和 ReentrantLock 区别是什么？
1）协调多线程对共享对象、变量的访问
2）可重入，同一线程可以多次获得同一个锁
3）都保证了可见性和互斥性
两者的不同点：
1）ReentrantLock显示获得、释放锁，synchronized隐式获得释放锁
2）ReentrantLock可响应中断、可轮回，synchronized是不可以响应中断的，为处理锁的不可用性提供了更高的灵活性
3）ReentrantLock是API级别的，synchronized是JVM级别的
4）ReentrantLock可以实现公平锁
5）ReentrantLock通过Condition可以绑定多个条件
6）底层实现不一样， synchronized是同步阻塞，使用的是悲观并发策略，lock是同步非阻塞，采用的是乐观并发策略
56.说一下 atomic 的原理？
以AtomicInteger为例
public class AtomicInteger extends Number implements java.io.Serializable { private static final long serialVersionUID = 6214790243416807050L; // 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 的内部属性可以看出，它依赖于Unsafe 提供的一些底层能力，进行底层操作；如根据valueOffset代表的该变量值在内存中的偏移地址，从而获取数据的。
- 变量value用volatile修饰，保证了多线程之间的内存可见性。
下面以getAndIncrement为例，说明其原子操作过程
/** * Atomically increments by one the current value. * * @return the previous value */ public final int getAndIncrement() { return unsafe.getAndAddInt(this, valueOffset, 1); }
public final int getAndAddInt(Object var1, long var2, int var4) { int var5; do { var5 = this.getIntVolatile(var1, var2); } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4)); return var5; }
- 假设线程1和线程2通过getIntVolatile拿到value的值都为1，线程1被挂起，线程2继续执行
- 线程2在compareAndSwapInt操作中由于预期值和内存值都为1，因此成功将内存值更新为2
- 线程1继续执行，在compareAndSwapInt操作中，预期值是1，而当前的内存值为2，CAS操作失败，什么都不做，返回false
- 线程1重新通过getIntVolatile拿到最新的value为2，再进行一次compareAndSwapInt操作，这次操作成功，内存值更新为3
如何保证原子性：自旋 + CAS（乐观锁）。在这个过程中，通过compareAndSwapInt比较更新value值，如果更新失败，重新获取，然后更新。
CAS是什么？
CAS是英文单词CompareAndSwap的缩写，中文意思是：比较并替换。CAS需要有3个操作数：内存地址V，旧的预期值A，即将要更新的目标值B。
CAS指令执行时，当且仅当内存地址V的值与预期值A相等时，将内存地址V的值修改为B，否则就什么都不做。整个比较并替换的操作是一个原子操作。
