InterV 2：线程

1. 什么是线程？

　　线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。程序员可以通过它进行多处理器编程，你可以使用多线程对运算密集型任务提速。比如，如果一个线程完成一个任务要100毫秒，那么用十个线程完成改任务只需10毫秒。

2. 线程和进程有什么区别？

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

3、多线程有几种实现方法?同步有几种实现方法?  

　 通常使用继承Thread类或实现Runnable接口，还可以通过Callable接口实现。

     同步的实现方法有两种，分别是synchronized,wait与notify

     wait():使一个线程处于等待状态，并且释放所持有的对象的lock。

     sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。

     notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。

     notityAll():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

用Runnable还是Thread？

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

Java中Runnable和Callable有什么不同？

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

4. Thread 类中的start() 和 run() 方法有什么区别？

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

5. 线程的状态转换

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

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

 

6. 如何停止一个线程 

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

所以停止一个线程的方法有：

1、run方法代码执行完成

2、线程运行时抛出一个未捕获的异常，跳出线程

3、通过标志位跳出线程

4、interrupt() 方法向需要中断的线程发送停止指令；isInterrupted()方法线程检查自己的中断标志位；Thread.interrupted() 将中断标志位复位为false；

7. 什么是线程安全

多个线程同时访问某个代码块时输出的结果和变量的值都是和预期的一样的就叫线程安全

8. synchronized如何使用

synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。

 synchronized 方法：通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如：  

public synchronized void accessVal(int newVal);

synchronized 块：通过 synchronized关键字来声明synchronized 块。语法如下：  
synchronized(syncObject) {  
//允许访问控制的代码  
}  

9. synchronized 和 ReentrantLock 有什么不同？

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

10. wait() 和 sleep()方法有什么不同？

相同点：wait 和 sleep都会造成某种形式的暂停，它们可以满足不同的需要。

不同点：

1、sleep()是线程Thread的方法，而wait()是Object对象的方法。

2、sleep()不会释放对象锁、wait()会释放对象锁

3、sleep()可以在任何地方调用，wait()方法只可以在同步方法或同步块中使用。

11. java中有几种方法可以实现一个线程？用什么关键字修饰同步方法? stop()和suspend()方法为何不推荐使用？

java5以前，有如下两种：

第一种：

     new Thread(){}.start();这表示调用Thread子类对象的run方法，new Thread(){}表示一个Thread的匿名子类的实例对象，子类加上run方法后的代码如下：

1 new Thread() {
2 
3             public void run() {
4 
5             }
6 
7         }.start();

第二种：

     new Thread(new Runnable(){}).start();这表示调用Thread对象接受的Runnable对象的run方法，new Runnable(){}表示一个Runnable的匿名子类的实例对象,runnable的子类加上run方法后的代码如下：

1 new Thread(new Runnable() {
2 
3             public void run() {
4 
5             }
6 
7         }
8 
9         ).start();

从java5开始，还有如下一些线程池创建多线程的方式：

 1 ExecutorService pool = Executors.newFixedThreadPool(3);
 2 
 3         for (int i = 0; i < 10; i++)
 4 
 5         {
 6 
 7             pool.execute(new Runable() {
 8                 public void run() {
 9                 }
10             });
11 
12         }
13 
14         Executors.newCachedThreadPool().execute(new Runable() {
15             public void run() {
16             }
17         });
18 
19         Executors.newSingleThreadExecutor().execute(new Runable() {
20             public void run() {
21             }
22         }
23 
24         );

用synchronized关键字修饰同步方法

Stop() 立刻停止线程，但不会释放线程运行所应用的资源

Suspend() 立刻挂起线程，但不会释放线程运行所应用的资源，容易造成死锁

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

12. 同步和异步有何异同，在什么情况下分别使用他们？举例说明。

同步：用户触发IO操作，你发起了请求就得等着对方给你返回结果，你不能走，针对调用方的，你发起了请求你等

异步：用户触发了IO操作，即发起了请求以后可以做自己的事，等处理完以后会给你返回处理完成的标志，针对调用方的，你发起了请求你不等

13. 启动一个线程是用run()还是start()?  

启动一个线程是调用start()方法，使线程就绪状态，以后可以被调度为运行状态，一个线程必须关联一些具体的执行代码，run()方法是该线程所关联的执行代码。

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

分几种情况：

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

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

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

15. 简述synchronized和java.util.concurrent.locks.Lock的异同？

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

主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。Lock还有更强大的功能，例如，它的tryLock方法可以非阻塞方式去拿锁。

synchronized是一个Java的关键字，Lock是一个接口；

synchronized代码块执行完或线程抛出异常时结束线程，Lock必须显示调用释放锁的方法:unlock()；

synchronized修饰的锁其他线程在等待获取锁的阶段，会一直阻塞等待直到得到锁为止（不可中断锁）；Lock有多种方式可以获取锁，不一定一直阻塞等待（可中断锁）。

synchronized无法判断锁的状态，Lock可以判断；

synchronized是非公平锁，而Lock可以设置为公平锁；

Lock用法：

lock()（阻塞线程等待获取锁）

lockInterruptibly():可中断（阻塞线程等待获取锁，会响应中断）

tryLock():尝试非阻塞的获取锁（非阻塞方式尝试获取锁，无法获取则返回false）

unlock()

公平锁与非公平锁：

公平锁，先对锁发出获取请求的一定先获得锁。非公平锁则反之（性能更高）。

ReentrantLock(boolean)可选择公平锁或非公平锁，默认使用非公平锁。

锁的可重入：

递归的时候发生锁的重入

synchronized隐式支持锁的重入

ReentrantLock的lock()支持锁的重入

排它锁：同一时刻只有一个线程获取锁；

读写锁：同一时刻运行多个读线程访问，但是只允许一个写线程，写锁会阻塞所有锁。（ReentrantReadWriteLock，相比synchronized速度更快）

Condition接口有何作用？

Condition接口与Lock配合，来实现等待通知机制。

16. volatile关键字

在多个线程之间，访问同一个被volatile修饰的对象时，所有线程共享这个对象的值。

但是volatile不是线程安全的（多个线程同时修改这个变量时，最终结果不一定是最后修改的那个值；可以保证线程的可见性，不可以保证操作的原子性）

17. synchronized如何使用

加锁

可以修饰方法或代码块以同步的方式执行（同一时间只会有一个线程执行）

类锁与实例锁本质上是两把锁，类锁锁的是每一个类的class对象。

18. 死锁、活锁

死锁：

当一个锁未被释放，其他线程无法获取锁的时候，程序产生死锁情况。

死锁的两种情况：

1、线程thread1先获取锁locka，然后在同步块里嵌套竞争锁lockb。而线程thread2先获取锁lockb，然后在同步块里嵌套竞争锁locka。

2、Lock.unlock()方法的错误使用，导致死锁。

活锁：

线程A和线程B分别拿到了锁A和锁B，同时线程A和线程B分别需要锁B和锁A，线程A和线程B发现对方需要自己持有的锁就释放自己持有的锁，这样循环处于拿锁和获取锁的情况就叫做活锁

如何避免死锁？

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

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

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

 19. 怎么检测一个线程是否拥有锁？

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

20. 你如何在Java中获取线程堆栈？

　　对于不同的操作系统，有多种方法来获得Java进程的线程堆栈。当你获取线程堆栈时，JVM会把所有线程的状态存到日志文件或者输出到控制台。

　　在Windows你可以使用Ctrl + Break组合键来获取线程堆栈，Linux下用kill -3命令。你也可以用jstack这个工具来获取，它对线程id进行操作，你可以用jps这个工具找到id。

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

　　 -Xss参数用来控制线程的堆栈大小。

22. Java线程池

什么是线程池？用于管理线程的一个工具。

线程池的作用？限制系统中执行线程的数量；降低资源的消耗、提高响应速度、提高线程的可管理性。

Java常见的线程池：

Executors.newSingleThreadExecutor：单个线程的线程池；

Executors.newFixedThreadExecutor：固定线程数量的线程池；

Executors.newCacheThreadExecutor：可缓存线程；

Executors.newScheduledThreadPool：创建一个定长线程池，支持定时和周期性的执行线程；

23. 并发工具类和并发容器类

常用的并发工具类：

闭锁：CountDownLatch

栅栏：CyclicBarrier

信号量：Semaphore

交换者：Exchanger

CountDownLatch 闭锁允许一个线程或多个线程等待特定情况，同步完成线程中其他任务。

CyclicBarrier和CountDownLatch都可以协同多个线程，让指定数量的线程等待期他所有的线程都满足某些条件之后才继续执行。CyclicBarrier可以重复使用(reset)，而CountDownLatch只能够使用一次，如果还需要使用，必须重新new一个CountDownLatch对象。

构造方法CyclicBarrier(int, Runnable) 所有线程达到屏障后，执行Runnable。

Semaphore 信号量用来控制同时访问特定资源的线程数量。

Java中Semaphore是什么？

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

Exchanger 交换者用于在两个线程之间传输数据，被调用后等待另一个线程达到交换点，然后相互交换数据。

常用的并发容器：

ConcurrentHashMap：JDK1.7实现：分段锁；JDK1.8实现：元素(key)锁+链表+红黑树

SkipList：跳表自动随机维护一套索引，用于高效的索引List中的有序数据。

 

ConcurrentSkipListMap：TreeMap的并发实现

ConcurrentSkipListSet：TreeSet的并发实现

ConcurrentLinkedQueue：LinkedList的并发实现

CopyOnWriteArrayList：写时复制，在添加元素是，复制一个新的容器，在新容器中新增元素；读数据都在Old容器中操作，进行读写分离。数据一致性较弱，适合读多写少的场景。

CopyOnWriteArraySet：同上

24. Java中什么是竞态条件？ 举个例子说明。

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

       解决竞态条件方法：使用线程的ThreadLocal变量

                                       ThreadLocal是Java里一种特殊的变量。每个线程都有一个ThreadLocal，就是每个线程都拥有了自己独立的一个变量，竞争条件被彻底消除了

                                       本质是个map，map的键就是每个线程对象，值就是每个线程所拥有的值

 

25. 一个线程运行时发生异常会怎样？

　　如果异常没有被捕获该线程将会停止执行。Thread.UncaughtExceptionHandler是用于处理未捕获异常造成线程突然中断情况的一个内嵌接口。当一个未捕获异常将造成线程中断的时候JVM会使用Thread.getUncaughtExceptionHandler()来查询线程的UncaughtExceptionHandler并将线程和异常作为参数传递给handler的uncaughtException()方法进行处理。

26. 如何在两个线程间共享数据？

　　可以通过共享对象来实现这个目的，或者是使用像阻塞队列这样并发的数据结构。

27. 为什么wait, notify 和 notifyAll这些方法不在thread类里面？

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

28. 什么是ThreadLocal变量？

ThreadLocal是Java里一种特殊的变量。每个线程都有一个ThreadLocal，就是每个线程都拥有了自己独立的一个变量，竞争条件被彻底消除了

本质是个map，map的键就是每个线程对象，值就是每个线程所拥有的值

常用方法：

initialValue()

get()

set()

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

ThreadLocal拥有的这个变量，在线程之间很独立的，相互之间没有联系。内存占用相对来说比较大。

29. 什么是FutureTask？

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

30. Java中interrupted 和 isInterrupted方法的区别？

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

interrupt() 向需要中断的线程发送停止指令；isInterrupted() 线程检查自己的中断标志位；Thread.interrupted() 将中断标志位复位为false；

31. 为什么wait和notify方法要在同步块中调用？

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

32. 为什么你应该在循环中检查等待条件?

　　处于等待状态的线程可能会收到错误警报和伪唤醒，如果不在循环中检查等待条件，程序就会在没有满足结束条件的情况下退出。在notify()方法调用之后和等待线程醒来之前这段时间它可能会改变。这就是在循环中使用wait()方法效果更好的原因。

33. Java中的同步集合与并发集合有什么区别？

　　同步集合与并发集合都为多线程和并发提供了合适的线程安全的集合，不过并发集合的可扩展性更高。

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

34. Java中堆和栈有什么不同？

　　为什么把这个问题归类在多线程和并发面试题里？

　　因为栈是一块和线程紧密相关的内存区域。每个线程都有自己的栈内存，用于存储本地变量，方法参数和栈调用，一个线程中存储的变量对其它线程是不可见的。

　　而堆是所有线程共享的一片公用内存区域。对象都在堆里创建，为了提升效率线程会从堆中弄一个缓存到自己的栈，如果多个线程使用该变量就可能引发问题，这时volatile 变量就可以发挥作用了，它要求线程从主存中读取变量的值。

35. 如何写代码来解决生产者消费者问题？

　　在现实中你解决的许多线程问题都属于生产者消费者模型，就是一个线程生产任务供其它线程进行消费，你必须知道怎么进行线程间通信来解决这个问题。

       比较低级的办法是用wait和notify来解决这个问题；比较赞的办法是用Semaphore 或者 BlockingQueue来实现生产者消费者模型

36. 有三个线程T1，T2，T3，怎么确保它们按顺序执行？

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

37. Thread类中的yield方法有什么作用？

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

38. Java中ConcurrentHashMap的并发度是什么？

　　ConcurrentHashMap把实际map划分成若干部分来实现它的可扩展性和线程安全。这种划分是使用并发度获得的。

　　并发度是ConcurrentHashMap类构造函数的一个可选参数，默认值为16。

　　并发度的作用：在多线程情况下就能避免争用。

39. 如果你提交任务时，线程池队列已满时会发会生什么？

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

40. Java线程池中submit() 和 execute()方法有什么区别？

相同点：　　

　　1. 两个方法都可以向线程池提交任务。

不同点：

　　1. execute()方法的返回类型是void，它定义在Executor接口中, 而submit()方法可以返回持有计算结果的Future对象，它定义在ExecutorService接口中，它扩展了Executor接口，其它线程池类像ScheduledThreadPoolExecutor都有 execute()和submit()方法。

41. 什么是阻塞式方法？

　　阻塞式方法是指程序会一直等待该方法完成期间不做其他事情。

　　ServerSocket的accept()方法就是一直等待客户端连接。

　　这里的阻塞是指调用结果返回之前，当前线程会被挂起，直到得到结果之后才会返回。此外，还有异步和非阻塞式方法在任务完成前就返回。

42. Java中的读写锁ReadWriteLock是什么？

读写锁的概念：Java中的读写锁ReadWriteLock是Java 5 中新增的一个接口，一个读写锁ReadWriteLock维护一对关联的锁：读锁和写锁，一个用于只读操作，一个用于写。

　　                  在没有写线程的情况下一个读锁可能会同时被多个读线程持有。写锁是独占的，你可以使用JDK中的ReentrantReadWriteLock来实现这个规则，它最多支持65535个写锁和65535个读锁。

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

43. 多线程中的忙循环是什么?

　　忙循环的概念：忙循环就是程序员用循环让一个线程等待，不像传统方法wait(), sleep() 或 yield() 它们都放弃了CPU控制，而忙循环不会放弃CPU，它就是在运行一个空循环。

　　忙循环的作用：使用忙循环的目的是为了保留CPU缓存，在多核系统中，一个等待线程醒来的时候可能会在另一个内核运行，这样会重建缓存。为了避免重建缓存和减少等待重建的时间就可以使用忙循环了。

44. volatile 变量和 atomic 变量有什么不同？

　　这是个有趣的问题。首先，volatile 变量和 atomic 变量看起来很像，但功能却不一样。

　　Volatile变量只能保证对象的可见性，单不能保证对象的线程安全。例如用volatile修饰count变量那么 count++ 操作就不是原子性的。

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

45. 如果同步块内的线程抛出异常会发生什么？

同步块内的线程抛出异常时，线程会释放锁。

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

 

46. 单例模式的双检锁是什么？

public class Singleton{  
  private static volatile Singleton single;    //声明静态的单例对象的变量  
  private Singleton(){}    //私有构造方法   
    
  public static Singleton getSingle(){    //外部通过此方法可以获取对象    
    if(single == null){     
        synchronized (Singleton.class) {   //保证了同一时间只能只能有一个对象访问此同步块        
            if(single == null){      
                single = new Singleton();          
        }     
      }  
    }    
    return single;   //返回创建好的对象   
  }  
}  

思路很简单，就是我们只需要同步（synchronize）初始化instance的那部分代码从而使代码既正确又很有效率。 
这就是所谓的“双检锁”机制（顾名思义）。

47. 如何在Java中创建线程安全的Singleton？

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

47.1 饥汉式——可用

饥汉式1——可用

package com.study.design.mode.service;

public class Singleton {
    private final static Singleton INSTANCE = new Singleton();

    private Singleton() {
    }

    public static Singleton getInstance() {
        return INSTANCE;
    }
}

 饥汉式2——可用

package com.study.design.mode.service;

public class Singleton {
    private static Singleton instance;
    static {
        instance = new Singleton();
    }

    private Singleton() {
    }

    public static Singleton getInstance() {
        return instance;
    }
}

47.2 懒汉式

 懒汉式4——双重检查——推荐使用

package com.study.design.mode.service;

public class Singleton {

    private static volatile Singleton singleton;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

注意：volatile关键字修饰很关键，保证可见性，一个线程先创建了，其他线程就就会看到这个改变，不会再创建，如果没有这个关键字还是不能保证单例。

优点：线程安全；延迟加载；效率较高

懒汉式5——静态内部类方式——推荐使用

package com.study.design.mode.service;

public class Singleton {
    private Singleton() {
    }

    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

优点：避免了线程不安全，延迟加载，效率高

原理：类的静态属性只会在第一次加载类的时候初始化。在这里，JVM的加载机制帮助我们保证了线程安全性，在类进行初始化时，别的线程是无法进入的

懒汉式6——用枚举——推荐使用

package com.study.design.mode.service;

public enum Singleton {
    INSTANCE;
    public void whateverMethod() {
    }
}

48. 写出3条你遵循的多线程最佳实践

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

• 给你的线程起个有意义的名字。 这样可以方便找bug或追踪。OrderProcessor, QuoteProcessor or TradeProcessor 这种名字比 Thread-1. Thread-2 and Thread-3 好多了，给线程起一个和它要完成的任务相关的名字，所有的主要框架甚至JDK都遵循这个最佳实践。
• 避免锁定和缩小同步的范围。 因为锁对于性能是有影响的，所以应尽量避免加锁，能不加锁的地方就不要加，不得不加的就要考虑在最小范围内加，这样才不会影响效率。因此相对于同步方法我更喜欢同步块，它给我拥有对锁的绝对控制权。
• 多用同步工具类少用wait 和 notify。 首先，CountDownLatch, Semaphore, CyclicBarrier 和 Exchanger 这些同步类简化了编码操作，而用wait和notify很难实现对复杂控制流的控制，写得不好还容易出bug。其次，这些类是由最好的企业编写和维护在后续的JDK中它们还会不断优化和完善，使用这些更高等级的同步工具你的程序可以不费吹灰之力获得优化。
• 多用并发集合少用同步集合。 这是另外一个容易遵循且受益巨大的最佳实践，并发集合比同步集合的可扩展性更好，所以在并发编程时使用并发集合效果更好。如果下一次你需要用到map，你应该首先想到用ConcurrentHashMap。

49. 如何强制启动一个线程？

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

50. Java中的fork join框架是什么？

　　fork join框架：并行执行任务的框架，把大任务拆分成很多的小任务，汇总每个小任务的结果得到大任务的结果。它是专门为了那些可以递归划分成许多子模块设计的，目的是将所有可用的处理能力用来提升程序的性能。

       fork join框架一个巨大的优势是它使用了工作窃取算法，可以完成更多任务的工作线程可以从其它线程中窃取任务来执行。

 

 

工作窃取算法

工作窃取（work-stealing）算法：某个线程从其他队列里窃取任务来执行，执行完以后把结果放回去

那么，为什么需要使用工作窃取算法呢？假如我们需要做一个比较大的任务，可以把这个任务分割为若干互不依赖的子任务，为了减少线程间的竞争，把这些子任务分别放到不同的队列里，并为每个队列创建一个单独的线程来执行队列里的任务，线程和队列一一对应。

比如A线程负责处理A队列里的任务。但是，有的线程会先把自己队列里的任务干完，而其他线程对应的队列里还有任务等待处理。干完活的线程与其等着，不如去帮其他线程干活，于是它就去其他线程的队列里窃取一个任务来执行。而在这时它们会访问同一个队列，所以为了减少窃取任务线程和被窃取任务线程之间的竞争，通常会使用双端队列，被窃取任务线程永远从双端队列的头部拿任务执行，而窃取任务的线程永远从双端队列的尾部拿任务执行。

https://www.cnblogs.com/leeSmall/p/8439263.html