Java 面试题 (三) --------- Java 线程、锁相关

川长思鸟来 2024-03-31 15:49 25阅读 0赞

**1、请谈谈 ReadWriteLock 和 StampedLock**

ReadWriteLock包括两种子锁

① ReadWriteLock

ReadWriteLock 可以实现多个读锁同时进行，但是读与写和写于写互斥，只能有一个写锁线程在进行。

② StampedLock

StampedLock 是 JDK 在1.8提供的一种读写锁，相比较 ReentrantReadWriteLock性能更好，因为 ReentrantReadWriteLock 在读写之间是互斥的，使用的是一种悲观策略，在读线程特别多的情况下，会造成写线程处于饥饿状态，虽然可以在初始化的时候设置为 true 指定为公平，但是吞吐量又下去了，而 StampedLock 是提供了一种乐观策略，更好的实现读写分离，并且吞吐量不会下降。

StampedLock包括三种锁：

① 写锁 writeLock：

writeLock是一个独占锁写锁，当一个线程获得该锁后，其他请求读锁或者写锁的线程阻塞， 获取成功后，会返回一个stamp（凭据）变量来表示该锁的版本，在释放锁时调用 unlockWrite 方法传递 stamp参数。提供了非阻塞式获取锁tryWriteLock。

② 悲观读锁 readLock：

readLock 是一个共享读锁，在没有线程获取写锁情况下，多个线程可以获取该锁。如果有写锁获取，那么其他线程请求读锁会被阻塞。悲观读锁会认为其他线程可能要对自己操作的数据进行修改，所以需要先对数据进行加锁，这是在读少写多的情况下考虑的。请求该锁成功后会返回一个 stamp 值，在释放锁时调用 unlockRead 方法传递 stamp 参数。提供了非阻塞式获取锁方法 tryWriteLock。

③ 乐观读锁 tryOptimisticRead：

tryOptimisticRead 相对比悲观读锁，在操作数据前并没有通过 CAS 设置锁的状态，如果没有线程获取写锁，则返回一个非0的 stamp 变量，获取该 stamp 后在操作数据前还需要调用 validate 方法来判断期间是否有线程获取了写锁，如果是返回值为 0 则有线程获取写锁，如果不是 0 则可以使用 stamp 变量的锁来操作数据。由于 tryOptimisticRead 并没有修改锁状态，所以不需要释放锁。这是读多写少的情况下考虑的，不涉及 CAS 操作，所以效率较高，在保证数据一致性上需要复制一份要操作的变量到方法栈中，并且在操作数据时可能其他写线程已经修改了数据，而我们操作的是方法栈里面的数据，也就是一个快照，所以最多返回的不是最新的数据，但是一致性得到了保证。

**2、线程的 run() 和 start() 有什么区别？**

每个线程都是通过某个特定 Thread 对象所对应的方法 run() 来完成其操作的，run() 方法称为线程体。通过调用 Thread 类的 start() 方法来启动一个线程。

start() 方法用于启动线程，run() 方法用于执行线程的运行时代码。run() 可以重复调用，而 start() 只能调用一次。

start() 方法来启动一个线程，真正实现了多线程运行。调用 start() 方法无需等待 run 方法体代码执行完毕，可以直接继续执行其他的代码。此时线程是处于就绪状态，并没有运行。 然后通过此 Thread 类调用方法 run() 来完成其运行状态， run()方法运行结束， 此线程终止。然后 CPU 再调度其它线程。

run() 方法是在本线程里的，只是线程里的一个函数，而不是多线程的。 如果直接调用 run()，其实就相当于是调用了一个普通函数而已，直接待用 run() 方法必须等待 run() 方法执行完毕才能执行下面的代码，所以执行路径还是只有一条，根本就没有线程的特征，所以在多线程执行时要使用 start() 方法而不是 run() 方法。

**3、为什么我们调用 start() 方法时会执行 run() 方法，为什么我们不能直接调用 run() 方法？**

这是另一个非常经典的 Java 多线程面试问题，而且在面试中会经常被问到。很简单，但是很多人都会答不上来！

new 一个 Thread，线程进入了新建状态。调用 start() 方法，会启动一个线程并使线程进入了就绪状态，当分配到时间片后就可以开始运行了。 start() 会执行线程的相应准备工作，然后自动执行 run() 方法的内容，这是真正的多线程工作。

而直接执行 run() 方法，会把 run 方法当成一个 main 线程下的普通方法去执行，并不会在某个线程中执行它，所以这并不是多线程工作。

总结： 调用 start 方法方可启动线程并使线程进入就绪状态，而 run 方法只是 thread 的一个普通方法调用，还是在主线程里执行。

**4、Synchronized 用过吗，其原理是什么？**

① 可重入性

synchronized的锁对象中有一个计数器（recursions变量）会记录线程获得几次锁。

可重入的好处：

*  可以避免死锁
 *  可以让我们更好的封装代码

synchronized 是可重入锁，每部锁对象会有一个计数器记录线程获取几次锁，在执行完同步代码块时，计数器的数量会 -1，直到计数器的数量为 0，就释放这个锁。

② 不可中断性：

一个线程获得锁后，另一个线程想要获得锁，必须处于阻塞或等待状态，如果第一个线程不释放锁，第二个线程会一直阻塞或等待，不可被中断。

*  synchronized 属于不可被中断；
 *  Lock lock方法是不可中断的；
 *  Lock tryLock方法是可中断的；

**5、JVM 对 Java 的原生锁做了哪些优化？**

① 自旋锁

在线程进行阻塞的时候，先让线程自旋等待一段时间，可能这段时间其它线程已经解锁，这时就无需让线程再进行阻塞操作了。

自旋默认次数是10次。

② 自适应自旋锁

自旋锁的升级，自旋的次数不再固定，由前一次自旋次数和锁的拥有者的状态决定

③ 锁消除

在动态编译同步代码块的时候，JIT编译器借助逃逸分析技术来判断锁对象是否只被一个线程访问，而没有其他线程，这时就可以取消锁了。

④ 锁粗化

当 JIT 编译器发现一系列的操作都对同一个对象反复加锁解锁，甚至加锁操作出现在循环中，此时会将加锁同步的范围粗化到整个操作系列的外部。

锁粒度：不要锁住一些无关的代码。

锁粗化：可以一次性执行完的不要多次加锁执行。

**6、为什么 wait(), notify()和 notifyAll()必须在同步方法或者同步块中被调用？**

Java中，任何对象都可以作为锁，并且 wait()，notify()等方法用于等待对象的锁或者唤醒线程，在 Java 的线程中并没有可供任何对象使用的锁，所以任意对象调用方法一定定义在Object 类中。

wait(), notify()和 notifyAll()这些方法在同步代码块中调用

有的人会说，既然是线程放弃对象锁，那也可以把 wait() 定义在 Thread 类里面啊，新定义的线程继承于 Thread 类，也不需要重新定义 wait() 方法的实现。然而，这样做有一个非常大的问题，一个线程完全可以持有很多锁，你一个线程放弃锁的时候，到底要放弃哪个锁？当然了，这种设计并不是不能实现，只是管理起来更加复杂。

综上所述，wait()、notify() 和 notifyAll() 方法要定义在 Object 类中。

**7、Java 如何实现多线程之间的通讯和协作？**

可以通过 中断 和 共享变量 的方式实现线程间的通讯和协作。

比如说最经典的生产者-消费者模型：当队列满时，生产者需要等待队列有空间才能继续往里面放入商品，而在等待的期间内，生产者必须释放对临界资源（即队列）的占用权。因为生产者如果不释放对临界资源的占用权，那么消费者就无法消费队列中的商品，就不会让队列有空间，那么生产者就会一直无限等待下去。因此，一般情况下，当队列满时，会让生产者交出对临界资源的占用权，并进入挂起状态。然后等待消费者消费了商品，然后消费者通知生产者队列有空间了。同样地，当队列空时，消费者也必须等待，等待生产者通知它队列中有商品了。这种互相通信的过程就是线程间的协作。

Java中线程通信协作的最常见的两种方式：

1、syncrhoized加锁的线程的Object类的wait()/notify()/notifyAll()

2、ReentrantLock类加锁的线程的Condition类的await()/signal()/signalAll()

线程间直接的数据交换：

通过管道进行线程间通信：1）字节流；2）字符流

**8、Thread 类中的 yield 方法有什么作用？**

yield() 应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用 yield() 的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证 yield() 达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

结论：yield() 从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下，yield() 将导致线程从运行状态转到可运行状态，但有可能没有效果。

**9、为什么说 Synchronized 是非公平锁？**

当锁被释放后，任何一个线程都有机会竞争得到锁，这样做的目的是提高效率，但缺点是可能产生线程饥饿现象。

**10、请谈谈 volatile 有什么特点，为什么它能保证变量对所有线程的可见性？**

volatile 只能作用于变量，保证了操作可见性和有序性，不保证原子性。

在 Java 的内存模型中分为主内存和工作内存，Java 内存模型规定所有的变量存储在主内存中，每条线程都有自己的工作内存。

主内存和工作内存之间的交互分为 8 个原子操作：

*  lock
 *  unlock
 *  read
 *  load
 *  assign
 *  use
 *  store
 *  write

volatile 修饰的变量，只有对 volatile 进行 assign 操作，才可以load，只有 load 才可以 use，这样就保证了在工作内存操作volatile 变量，都会同步到主内存中。

**11、为什么说 Synchronized 是一个悲观锁？乐观锁的实现原理又是什么？什么是 CAS，它有什么特性？**

Synchronized 的并发策略是悲观的，不管是否产生竞争，任何数据的操作都必须加锁。

乐观锁的核心是 CAS，CAS 包括内存值、预期值、新值，只有当内存值等于预期值时，才会将内存值修改为新值。

**12、乐观锁一定就是好的吗？**

乐观锁认为对一个对象的操作不会引发冲突，所以每次操作都不进行加锁，只是在最后提交更改时验证是否发生冲突，如果冲突则再试一遍，直至成功为止，这个尝试的过程称为自旋。

乐观锁没有加锁，但乐观锁引入了 ABA 问题，此时一般采用版本号进行控制。

也可能产生自旋次数过多问题，此时并不能提高效率，反而不如直接加锁的效率高。

只能保证一个对象的原子性，可以封装成对象，再进行CAS操作；

**13、请尽可能详尽地对比下 Synchronized 和 ReentrantLock 的异同**

（1）相似点

它们都是阻塞式的同步，也就是说一个线程获得了对象锁，进入代码块，其它访问该同步块的线程都必须阻塞在同步代码块外面等待，而进行线程阻塞和唤醒的代码是比较高的。

（2）功能区别

Synchronized 是 Java 语言的关键字，是原生语法层面的互斥，需要 JVM 实现；ReentrantLock 是 JDK1.5 之后提供的 API 层面的互斥锁，需要 lock 和 unlock() 方法配合 try/finally 代码块来完成。

Synchronized 使用较 ReentrantLock 便利一些。

锁的细粒度和灵活性：ReentrantLock 强于 Synchronized；

（3）性能区别

Synchronized 引入偏向锁，自旋锁之后，两者的性能差不多，在这种情况下，官方建议使用 Synchronized。

① Synchronized

Synchronized 会在同步块的前后分别形成 monitorenter 和monitorexit 两个字节码指令。

在执行 monitorenter 指令时，首先要尝试获取对象锁。如果这个对象没被锁定，或者当前线程已经拥有了那个对象锁，把锁的计数器 +1，相应的执行 monitorexit 时，计数器 -1，当计数器为 0 时，锁就会被释放。如果获取锁失败，当前线程就要阻塞，知道对象锁被另一个线程释放为止。

② ReentrantLock

ReentrantLock 是 java.util.concurrent 包下提供的一套互斥锁，相比 Synchronized，ReentrantLock 类提供了一些高级功能，主要有如下三项：

等待可中断，持有锁的线程长期不释放的时候，正在等待的线程可以选择放弃等待，这相当于Synchronized避免出现死锁的情况。通过 lock.lockInterruptibly() 来实现这一机制。

公平锁，多个线程等待同一个锁时，必须按照申请锁的时间顺序获得锁，Synchronized 锁是非公平锁；ReentrantLock 默认也是非公平锁，可以通过参数true设为公平锁，但公平锁表现的性能不是很好。

锁绑定多个条件，一个 ReentrantLock 对象可以同时绑定多个对象。ReentrantLock 提供了一个 Condition(条件) 类，用来实现分组唤醒需要唤醒的线程们，而不是像 Synchronized 要么随机唤醒一个线程，要么唤醒全部线程。

ReentrantLock 是如何实现可重入性的？

（1）什么是可重入性

一个线程持有锁时，当其他线程尝试获取该锁时，会被阻塞；而这个线程尝试获取自己持有锁时，如果成功说明该锁是可重入的，反之则不可重入。

（2）synchronized是如何实现可重入性

synchronized关键字经过编译后，会在同步块的前后分别形成monitorenter和monitorexit两个字节码指令。每个锁对象内部维护一个计数器，该计数器初始值为0，表示任何线程都可以获取该锁并执行相应的方法。根据虚拟机规范要求，在执行monitorenter指令时，首先要尝试获取对象的锁，如果这个对象没有被锁定，或者当前线程已经拥有了对象的锁，把锁的计数器+1，相应的在执行monitorexit指令后锁计数器-1，当计数器为0时，锁就被释放。如果获取对象锁失败，那当前线程就要阻塞等待，直到对象锁被另一个线程释放为止。

（3）ReentrantLock 如何实现可重入性

ReentrantLock 使用内部类 Sync 来管理锁，所以真正的获取锁是由 Sync 的实现类控制的。Sync 有两个实现，分别为 NonfairSync（非公公平锁）和 FairSync（公平锁）。Sync 通过继承 AQS 实现，在 AQS 中维护了一个 private volatile int state 来计算重入次数，避免频繁的持有释放操作带来的线程问题。

（4）ReentrantLock代码实例

// Sync继承于AQS
    abstract static class Sync extends AbstractQueuedSynchronizer {
        
      ...
    }
    // ReentrantLock默认是非公平锁
    public ReentrantLock() {
        
        sync = new NonfairSync();
    }
    // 可以通过向构造方法中传true来实现公平锁
    public ReentrantLock(boolean fair) {
        
        sync = fair ? new FairSync() : new NonfairSync();
    }
    
    
    protected final boolean tryAcquire(int acquires) {
        
        // 当前想要获取锁的线程
        final Thread current = Thread.currentThread();
        // 当前锁的状态
        int c = getState();
        // state == 0 此时此刻没有线程持有锁
        if (c == 0) {
        
            // 虽然此时此刻锁是可以用的，但是这是公平锁，既然是公平，就得讲究先来后到，
            // 看看有没有别人在队列中等了半天了
            if (!hasQueuedPredecessors() &&
                // 如果没有线程在等待，那就用CAS尝试一下，成功了就获取到锁了，
                // 不成功的话，只能说明一个问题，就在刚刚几乎同一时刻有个线程抢先了 =_=
                // 因为刚刚还没人的，我判断过了
                compareAndSetState(0, acquires)) {
        
    
                // 到这里就是获取到锁了，标记一下，告诉大家，现在是我占用了锁
                setExclusiveOwnerThread(current);
                return true;
            }
        }
          // 会进入这个else if分支，说明是重入了，需要操作：state=state+1
        // 这里不存在并发问题
        else if (current == getExclusiveOwnerThread()) {
        
            int nextc = c + acquires;
            if (nextc < 0)
                throw new Error("Maximum lock count exceeded");
            setState(nextc);
            return true;
        }
        // 如果到这里，说明前面的if和else if都没有返回true，说明没有获取到锁
        return false;
    }

（5）代码分析

当一个线程在获取锁过程中，先判断state的值是否为0，如果是表示没有线程持有锁，就可以尝试获取锁。  
当state的值不为0时，表示锁已经被一个线程占用了，这时会做一个判断current==getExclusiveOwnerThread()，这个方法返回的是当前持有锁的线程，这个判断是看当前持有锁的线程是不是自己，如果是自己，那么将state的值+1，表示重入返回即可。

**14、什么是锁消除和锁粗化？**

（1）锁消除

所消除就是虚拟机根据一个对象是否真正存在同步情况，若不存在同步情况，则对该对象的访问无需经过加锁解锁的操作。

比如StringBuffer的append方法，因为append方法需要判断对象是否被占用，而如果代码不存在锁竞争，那么这部分的性能消耗是无意义的。于是虚拟机在即时编译的时候就会将上面的代码进行优化，也就是锁消除。

@Override
    public synchronized StringBuffer append(String str) {
        
        toStringCache = null;
        super.append(str);
        return this;
    }

从源码可以看出，append方法用了 synchronized关键字，它是线程安全的。但我们可能仅在线程内部把StringBuffer当做局部变量使用；StringBuffer仅在方法内作用域有效，不存在线程安全的问题，这时我们可以通过编译器将其优化，将锁消除，前提是Java必须运行在server模式，同时必须开启逃逸分析；

-server -XX:+DoEscapeAnalysis -XX:+EliminateLocks

其中+DoEscapeAnalysis表示开启逃逸分析，+EliminateLocks表示锁消除。

public static String createStringBuffer(String str1, String str2) {
        
        StringBuffer sBuf = new StringBuffer();
        sBuf.append(str1);// append方法是同步操作
        sBuf.append(str2);
        return sBuf.toString();
    }

逃逸分析：比如上面的代码，它要看sBuf是否可能逃出它的作用域？如果将sBuf作为方法的返回值进行返回，那么它在方法外部可能被当作一个全局对象使用，就有可能发生线程安全问题，这时就可以说sBuf这个对象发生逃逸了，因而不应将append操作的锁消除，但我们上面的代码没有发生锁逃逸，锁消除就可以带来一定的性能提升。

（2）锁粗化

锁的请求、同步、释放都会消耗一定的系统资源，如果高频的锁请求反而不利于系统性能的优化，锁粗化就是把多次的锁请求合并成一个请求，扩大锁的范围，降低锁请求、同步、释放带来的性能损耗。

**15、跟 Synchronized 相比，可重入锁 ReentrantLock 其实现原理有什么不同？**

（1）都是可重入锁；

（2）ReentrantLock内部是实现了Sync，Sync继承于AQS抽象类。Sync有两个实现，一个是公平锁，一个是非公平锁，通过构造函数定义。AQS中维护了一个state来计算重入次数，避免频繁的持有释放操作带来的线程问题。

（3）ReentrantLock只能定义代码块，而Synchronized可以定义方法和代码块；

（4）Synchronized 是 JVM 的一个内部关键字，ReentrantLock是JDK1.5之后引入的一个API层面的互斥锁；

（5）Synchronized 实现自动的加锁、释放锁，ReentrantLock需要手动加锁和释放锁，中间可以暂停；

（6）Synchronized由于引进了偏向锁和自旋锁，所以性能上和ReentrantLock差不多，但操作上方便很多，所以优先使用Synchronized。

**16、那么请谈谈 AQS 框架是怎么回事儿？**

（1）AQS 是 AbstractQueuedSynchronizer 的缩写，它提供了一个 FIFO 队列，可以看成是一个实现同步锁的核心组件。

AQS 是一个抽象类，主要通过继承的方式来使用，它本身没有实现任何的同步接口，仅仅是定义了同步状态的获取和释放的方法来提供自定义的同步组件。

（2）AQS 的两种功能：独占锁和共享锁

（3）AQS 的内部实现

AQS 的实现依赖内部的同步队列，也就是 FIFO 的双向队列，如果当前线程竞争失败，那么 AQS 会把当前线程以及等待状态信息构造成一个 Node 加入到同步队列中，同时再阻塞该线程。当获取锁的线程释放锁以后，会从队列中唤醒一个阻塞的节点（线程）。

AQS 队列内部维护的是一个 FIFO 的双向链表，这种结构的特点是每个数据结构都有两个指针，分别指向直接的后继节点和直接前驱节点。所以双向链表可以从任意一个节点开始很方便的范文前驱和后继节点。每个 Node 其实是由线程封装，当线程争抢锁失败后会封装成 Node 加入到 AQS 队列中。

**17、AQS 对资源的共享方式？**

AQS定义两种资源共享方式

（1）Exclusive（独占）

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

*  公平锁：按照线程在队列中的排队顺序，先到者先拿到锁
 *  非公平锁：当线程要获取锁时，无视队列顺序直接去抢锁，谁抢到就是谁的

（2）Share（共享）

多个线程可同时执行，如Semaphore/CountDownLatch。Semaphore、CountDownLatch、 CyclicBarrier、ReadWriteLock 我们都会在后面讲到。

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

不同的自定义同步器争用共享资源的方式也不同。自定义同步器在实现时只需要实现共享资源 state 的获取与释放方式即可，至于具体线程等待队列的维护（如获取资源失败入队/唤醒出队等），AQS已经在顶层实现好了。

**18、如何让 Java 的线程彼此同步？**

*  synchronized
 *  volatile
 *  ReenreantLock
 *  使用局部变量实现线程同步

**19、你了解过哪些同步器？请分别介绍下。**

（1）Semaphore同步器

特征：

*  经典的信号量，通过计数器控制对共享资源的访问
 *  Semaphore(int count):创建拥有count个许可证的信号量
 *  acquire()/acquire(int num) : 获取1/num个许可证
 *  release/release(int num) : 释放1/num个许可证

（2）CountDownLatch同步器

特征：

*  必须发生指定数量的事件后才可以继续运行(比如赛跑比赛，裁判喊出3,2,1之后大家才同时跑)
 *  CountDownLatch(int count): 必须发生count个数量才可以打开锁存器
 *  await: 等待锁存器
 *  countDown: 触发事件

（3）CyclicBarrier同步器

特征：

*  适用于只有多个线程都到达预定点时才可以继续执行(比如斗地主，需要等齐三个人才开始)
 *  CyclicBarrier(int num) :等待线程的数量
 *  CyclicBarrier(int num, Runnable action) :等待线程的数量以及所有线程到达后的操作
 *  await() : 到达临界点后暂停线程

（4）交换器(Exchanger)同步器

（5）Phaser同步器

**20、Java 中的线程池是如何实现的 ？**

创建一个阻塞队列来容纳任务，在第一次执行任务时创建足够多的线程，并处理任务，之后每个工作线程自动从任务队列中获取线程，直到任务队列中任务为0为止，此时线程处于等待状态，一旦有工作任务加入任务队列中，即刻唤醒工作线程进行处理，实现线程的可复用性。

线程池一般包括四个基本组成部分：

（1）线程池管理器

用于创建线程池，销毁线程池，添加新任务。

（2）工作线程

线程池中线程，可循环执行任务，在没有任务时处于等待状态。

（3）任务队列

用于存放没有处理的任务，一种缓存机制。

（4）任务接口

每个任务必须实现的接口，供工作线程调度任务的执行，主要规定了任务的开始和收尾工作，和任务的状态。

**21、创建线程池的几个核心构造参数**

// Java线程池的完整构造函数
    public ThreadPoolExecutor(
    	int corePoolSize, // 线程池长期维持的最小线程数，即使线程处于Idle状态，也不会回收。
    	int maximumPoolSize, // 线程数的上限
    	long keepAliveTime, // 线程最大生命周期。
    	TimeUnit unit, //时间单位                                 
    	BlockingQueue<Runnable> workQueue, //任务队列。当线程池中的线程都处于运行状态，而此时任务数量继续增加，则需要一个容器来容纳这些任务，这就是任务队列。
    	ThreadFactory threadFactory, // 线程工厂。定义如何启动一个线程，可以设置线程名称，并且可以确认是否是后台线程等。
    	RejectedExecutionHandler handler // 拒绝任务处理器。由于超出线程数量和队列容量而对继续增加的任务进行处理的程序。
    )

**22、线程池中的线程是怎么创建的？是一开始就随着线程池的启动创建好的吗？**

线程池中的线程是在第一次提交任务 submit 时创建的

创建线程的方式有继承 Thread 和实现 Runnable，重写 run 方法，start 开始执行，wait 等待，sleep 休眠，shutdown 停止。

（1）newSingleThreadExecutor：单线程池。

顾名思义就是一个池中只有一个线程在运行，该线程永不超时，而且由于是一个线程，当有多个任务需要处理时，会将它们放置到一个无界阻塞队列中逐个处理，它的实现代码如下：

public static ExecutorService newSingleThreadExecutor() {
        
        return new FinalizableDelegatedExecutorService (new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable()));
    }

它的使用方法也很简单，下面是简单的示例：

public static void main(String[] args) throws ExecutionException,InterruptedException {
        
        // 创建单线程执行器
        ExecutorService es = Executors.newSingleThreadExecutor();
        // 执行一个任务
        Future<String> future = es.submit(new Callable<String>() {
        
            @Override
            public String call() throws Exception {
        
                return "";
            }
        });
        // 获得任务执行后的返回值
        System.out.println("返回值：" + future.get());
        // 关闭执行器
        es.shutdown();
    }

（2）newCachedThreadPool：缓冲功能的线程。

建立了一个线程池，而且线程数量是没有限制的(当然，不能超过Integer的最大值)，新增一个任务即有一个线程处理，或者复用之前空闲的线程，或者重亲启动一个线程，但是一旦一个线程在60秒内一直处于等待状态时（也就是一分钟无事可做），则会被终止，其源码如下：

public static ExecutorService newCachedThreadPool() {
        
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
    }

这里需要说明的是，任务队列使用了同步阻塞队列，这意味着向队列中加入一个元素，即可唤醒一个线程(新创建的线程或复用空闲线程来处理)，这种队列已经没有队列深度的概念了。

（3）newFixedThreadPool：固定线程数量的线程池。

在初始化时已经决定了线程的最大数量，若任务添加的能力超出了线程的处理能力，则建立阻塞队列容纳多余的任务，其源码如下：

public static ExecutorService newFixedThreadPool(int nThreads) {
        
        return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());
    }

上面返回的是一个ThreadPoolExecutor，它的 corePoolSize 和 maximumPoolSize 是相等的，也就是说，最大线程数量为 nThreads。如果任务增 长的速度非常快，超过了、LinkedBlockingQuene 的最大容量( Integer 的最大值)，那此时会如何处理呢？会按照 ThreadPoolExecutor 默认的拒绝策略(默认是DiscardPolicy，直接丢弃) 来处理。

以上三种线程池执行器都是 ThreadPoolExecutor 的简化版，目的是帮助开发人员屏蔽过得线程细节，简化多线程开发。当需要运行异步任务时，可以直接通过 Executors 获得一个线程池，然后运行任务，不需要关注 ThreadPoolExecutor 的一系列参数时什么含义。当然，有时候这三个线程不能满足要求，此时则可以直接操作 ThreadPoolExecutor 来实现复杂的多线程计算。

newSingleThreadExecutor、newCachedThreadPool、newFixedThreadPool是线程池的简化版，而ThreadPoolExecutor 则是旗舰版，简化版容易操作，需要了解的知识相对少些，方便使用，而旗舰版功能齐全，适用面广，难以驾驭。

**23、volatile 关键字的作用**

对于可见性，Java 提供了 volatile 关键字来保证可见性和禁止指令重排。 volatile 提供 happens-before 的保证，确保一个线程的修改能对其他线程是可见的。当一个共享变量被 volatile 修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，它会去内存中读取新值。

从实践角度而言，volatile 的一个重要作用就是和 CAS 结合，保证了原子性，详细的可以参见 java.util.concurrent.atomic 包下的类，比如 AtomicInteger。

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

**24、既然 volatile 能够保证线程间的变量可见性，是不是就意味着基于 volatile 变量的运算就是并发安全的？**

volatile 修饰的变量在各个线程的工作内存中不存在一致性的问题（在各个线程工作的内存中，volatile 修饰的变量也会存在不一致的情况，但是由于每次使用之前都会先刷新主存中的数据到工作内存，执行引擎看不到不一致的情况，因此可以认为不存在不一致的问题），但是 Java 的运算并非原子性的操作，导致 volatile 在并发下并非是线程安全的。

**25、ThreadLocal 是什么？有哪些使用场景？**

ThreadLocal 是一个本地线程副本变量工具类，在每个线程中都创建了一个 ThreadLocalMap 对象，简单说 ThreadLocal 就是一种以空间换时间的做法，每个线程可以访问自己内部 ThreadLocalMap 对象内的 value。通过这种方式，避免资源在多线程间共享。

原理：线程局部变量是局限于线程内部的变量，属于线程自身所有，不在多个线程间共享。Java 提供 ThreadLocal 类来支持线程局部变量，是一种实现线程安全的方式。但是在管理环境下（如 web 服务器）使用线程局部变量的时候要特别小心，在这种情况下，工作线程的生命周期比任何应用变量的生命周期都要长。任何线程局部变量一旦在工作完成后没有释放，Java 应用就存在内存泄露的风险。

经典的使用场景是为每个线程分配一个 JDBC 连接 Connection。这样就可以保证每个线程的都在各自的Connection 上进行数据库的操作，不会出现 A 线程关了 B线程正在使用的 Connection； 还有 Session 管理 等问题。

**25、请谈谈 ThreadLocal 是怎么解决并发安全的？**

在 Java 程序中，常用的有两种机制来解决多线程并发问题，一种是sychronized方式，通过锁机制，一个线程执行时，让另一个线程等待，是以时间换空间的方式来让多线程串行执行。而另外一种方式就是ThreadLocal方式，通过创建线程局部变量，以空间换时间的方式来让多线程并行执行。两种方式各有优劣，适用于不同的场景，要根据不同的业务场景来进行选择。

在spring的源码中，就使用了ThreadLocal来管理连接，在很多开源项目中，都经常使用ThreadLocal来控制多线程并发问题，因为它足够的简单，我们不需要关心是否有线程安全问题，因为变量是每个线程所特有的。

**26、很多人都说要慎用 ThreadLocal，谈谈你的理解，使用 ThreadLocal 需要注意些什么？**

ThreadLocal 变量解决了多线程环境下单个线程中变量的共享问题，使用名为 ThreadLocalMap 的哈希表进行维护 (key为ThreadLocal 变量名，value为 ThreadLocal 变量的值) ；

使用时需要注意以下几点：

线程之间的 ThreadLocal 变量是互不影响的。使用 private final static 进行修饰，防止多实例时内存的泄露问题。线程池环境下使用后将threadLocal变量remove掉或设置成一个初始值。

**27、为什么代码会重排序？**

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

*  在单线程环境下不能改变程序运行的结果；
 *  存在数据依赖关系的不允许重排序

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

**28、什么是自旋**

很多 synchronized 里面的代码只是一些很简单的代码，执行时间非常快，此时等待的线程都加锁可能是一种不太值得的操作，因为线程阻塞涉及到用户态和内核态切换的问题。既然 synchronized 里面的代码执行得非常快，不妨让等待锁的线程不要被阻塞，而是在 synchronized 的边界做忙循环，这就是自旋。如果做了多次循环发现还没有获得锁，再阻塞，这样可能是一种更好的策略。

**29、多线程中 synchronized 锁升级的原理是什么？**

synchronized 锁升级原理：在锁对象的对象头里面有一个 threadid 字段，在第一次访问的时候 threadid 为空，jvm 让其持有偏向锁，并将 threadid 设置为其线程 id，再次进入的时候会先判断 threadid 是否与其线程 id 一致，如果一致则可以直接使用此对象，如果不一致，则升级偏向锁为轻量级锁，通过自旋循环一定次数来获取锁，执行一定次数之后，如果还没有正常获取到要使用的对象，此时就会把锁从轻量级升级为重量级锁，此过程就构成了 synchronized 锁的升级。

锁的升级的目的：锁升级是为了减低了锁带来的性能消耗。在 Java 6 之后优化 synchronized 的实现方式，使用了偏向锁升级为轻量级锁再升级到重量级锁的方式，从而减低了锁带来的性能消耗。

**30、synchronized 和 ReentrantLock 区别是什么？**

synchronized 是和 if、else、for、while 一样的关键字，ReentrantLock 是类，这是二者的本质区别。既然 ReentrantLock 是类，那么它就提供了比synchronized 更多更灵活的特性，可以被继承、可以有方法、可以有各种各样的类变量

synchronized 早期的实现比较低效，对比 ReentrantLock，大多数场景性能都相差较大，但是在 Java 6 中对 synchronized 进行了非常多的改进。

相同点：两者都是可重入锁

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

主要区别如下：

ReentrantLock 使用起来比较灵活，但是必须有释放锁的配合动作；  
ReentrantLock 必须手动获取与释放锁，而 synchronized 不需要手动释放和开启锁；  
ReentrantLock 只适用于代码块锁，而 synchronized 可以修饰类、方法、变量等。  
二者的锁机制其实也是不一样的。ReentrantLock 底层调用的是 Unsafe 的park 方法加锁，synchronized 操作的应该是对象头中 mark word  
Java中每一个对象都可以作为锁，这是synchronized实现同步的基础：

普通同步方法，锁是当前实例对象  
静态同步方法，锁是当前类的class对象  
同步方法块，锁是括号里面的对象

**31、Java Concurrency API 中的 Lock 接口 (Lock interface) 是什么？对比同步它有什么优势？**

Lock 接口比同步方法和同步块提供了更具扩展性的锁操作。他们允许更灵活的结构，可以具有完全不同的性质，并且可以支持多个相关类的条件对象。

它的优势有：

（1）可以使锁更公平

（2）可以使线程在等待锁的时候响应中断

（3）可以让线程尝试获取锁，并在无法获取锁的时候立即返回或者等待一段时间

（4）可以在不同的范围，以不同的顺序获取和释放锁

整体上来说 Lock 是 synchronized 的扩展版，Lock 提供了无条件的、可轮询的 (tryLock 方法) 、定时的 (tryLock 带参方法) 、可中断的 (lockInterruptibly) 、可多条件队列的 (newCondition 方法) 锁操作。另外 Lock 的实现类基本都支持非公平锁 (默认) 和公平锁，synchronized 只支持非公平锁，当然，在大部分情况下，非公平锁是高效的选择。