多线程面试题

柔光的暖阳◎ 2022-05-15 15:24 253阅读 0赞

**多线程，线程池，线程安全 **

**多线程**

1.  程序、进程、线程的区别是什么? 举个现实的例子说明。
    
    1.  程序（Program）：是一个指令的集合。程序不能独立执行，只有被加载到内存中，系统为它分配资源后才能执行
    2.  进程（Process）：一个执行中的程序称为进程。  
        进程是系统分配资源的独立单位，每个进程占有特定的地址空间。  
        程序是进程的静态文本描述，进程是程序在系统内顺序执行的动态活动。
    3.  线程（Thread）：是进程的“单一的连续控制流程“。  
        线程是CPU调度和分配的基本单位，是比进程更小的能独立运行的基本单位。  
        线程不能独立存在，必须依附于某个进程。一个进程可以包括多个并行的线程，一个线程肯定属于一个进程。  
        Java虚拟机允许应用程序并发地执行多个线程。
    4.  举例：如一个车间是一个程序，一个正在进行生产任务的车间是一个进程，车间内每个从事不同工作的工人是一个线程。
2.  线程的几种状态
    
    1.  新建状态（New）：新创建了一个线程对象。
    2.  可运行状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。
    3.  运行状态（Running）：就绪状态的线程获取了CPU，开始执行线程的run()方法。 
    4.  阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况又分为三种：
        
        1.  等待阻塞：运行的线程执行wait()方法，该线程会释放占用的所有资源，JVM会把该线程放入“对象等待池”中。进入这个状态后，是不能自动唤醒的，必须依靠其他线程调用对象的notify()或notifyAll()方法才能被唤醒，**wait****是object****类的方法**
        2.  同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入“锁等待池”中。
        3.  其他阻塞：运行的线程执行sleep()，JVM会把该线程置为阻塞状态。当sleep()状态超时时，线程重新转入可运行状态。**sleep****是Thread****类的方法**
    5.  死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。
3.  Java中通过哪些方式创建多线程类?
    
    1.  **继承****Thread类创建线程，Thread类有实现Runnable接口**
    2.  **实现****Runnable****接口创建线程**
    3.  匿名内部类
4.  用Runnable还是Thread？  
    这个问题是上题的后续，大家都知道我们可以通过继承Thread类或者调用Runnable接口来实现线程，问题是，那个方法更好呢？什么情况下使 用它？这个问题很容易回答，如果你知道Java不支持类的多重继承，但允许你调用多个接口。所以如果你要继承其他类，当然是调用Runnable接口好 了。
5.  Thread 类中的start() 和 run() 方法有什么区别？  
    这个问题经常被问到，但还是能从此区分出面试者对Java线程模型的理解程度。start()方法被用来启动新创建的线程，而且start()内部 调用了run()方法，这和直接调用run()方法的效果不一样。当你调用run()方法的时候，只会是在原来的线程中调用，没有新的线程启动，start()方法才会启动新线程。
6.  当调用一个线程对象的start方法后，线程马上进入运行状态吗?  
    不是，只是进入可运行状态，等待分配CPU时间片。一旦得到CPU时间片，即进入运行状态。
7.  A线程的优先级是10，B线程的优先级是1，那么当进行调度时一定会调用A吗?A线程的优先级是10，B线程的优先级是1，那么当进行调度时一定会调用A吗?（线程的调度）  
    **不一定，Java中在对线程调度时，也采用了优先级调度策略，具体策略为：“优先级高的线程应该有更大的获取CPU资源执行的概率，优先级低的线程并不是总不能执行****”。**
8.  Sleep()和yield()有什么区别
    
    1.  sleep()方法给其他线程运行机会时不考虑线程的优先级，因此会给低优先级的线程以运行的机会；  
        yield()方法只会给相同优先级或更高优先级的线程以运行的机会；
    2.  线程执行sleep()方法后转入阻塞（blocked）状态，执行yield()的线程有可能在进入到暂停状态后马上又被执行
    3.  sleep()方法声明抛出InterruptedException，而yield()方法没有声明任何异常；
    4.  sleep()方法比yield()方法（跟操作系统相关）具有更好的可移植性。
9.  说说：sleep、yield、join、wait方法的区别。
    
    1.  **sleep**()方法需要指定等待的时间，它可以让当前正在执行的线程在指定的时间内暂停执行，进入同步阻塞状态，该方法既可以让其他同优先级或者高优先级的线程得到执行的机会，也可以让低优先级的线程得到执行机会。但是sleep()方法不会释放“锁标志”，也就是说如果有synchronized同步块，其他线程仍然不能访问共享数据。 **作用于线程**
        
        1.  Thread.sleep()方法用来暂停线程的执行，将CPU放给线程调度器。
        2.  Java有两种sleep方法，一个只有一个毫秒参数，另一个有毫秒和纳秒两个参数。
        3.  与wait方法不同，sleep方法不会释放锁
        4.  如果其他的线程中断了一个休眠的线程，sleep方法会抛出Interrupted Exception。
        5.  休眠的线程在唤醒之后不保证能获取到CPU，它会先进入可运行状态，与其他线程竞争CPU。
        6.  Thread.sleep()方法是一个静态方法，它暂停的是当前执行的线程。
    2.  **join**(): 当前线程等待，调用此方法的线程执行结束再继续执行。如：在main方法中调用t.join(),那main方法在此时进入阻塞状态，一直等t线程执行完，main方法再恢复到就绪状态，准备继续执行。  
        join方法必须在线程start方法调用之后调用才有意义。这个也很容易理解：如果一个线程都没有start，那它也就无法同步了。**作用于线程**
    3.  **yield**(): 可以暂停当前正在执行的线程对象，从而让其相同优先级的线程有机会运行。它是一个静态方法而且只保证当前线程放弃CPU占用而不能保证使其它线程一定能占用CPU，执行yield()的线程有可能在进入到暂停状态后马上又被执行。**作用于线程**
    4.  **wait**():
        
        1.  wait方法是针对一个被**同步代码块**加锁的对象，也就是说wait只能在同步（synchronize）环境中被调用
        2.  wait方法在进入wait状态的时候**会释放对象的锁**
        3.  进入wait状态的线程能够被notify和notifyAll线程唤醒
10. **wait、notify、notifyAll是在Thread类中定义的方法吗？作用分别是什么？**  
    wait(),notify(),notifyAll()不属于Thread类,而是属于Object类,也就是说每个对象都有wait(),notify(),notifyAll()的功能。  
    因为同步锁的是对象，而wait(),notify(),notifyAll()都是跟锁有关的方法。  
    三个方法的作用分别是：
    
    1.  **wait**：当线程执行了对一个特定对象的wait（）调用时，那个线程被放到特定对象的等待池中。此外，调用wait（)的线程自动释放对象的锁标志。
    2.  **notify**：对象调用notify（）方法时，将从对象的等待池中移走一个任意的线程，并放到对象的锁等待池中，直到获得对象的锁标志。
    3.  **notifyAll**: 对象调用notifyAll（）方法时，将从对象的等待池中移走所有的线程，并放到对象的锁等待池中，直到获得对象的锁标志。
11. 现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行？  
    这个线程问题通常会在第一轮或电话面试阶段被问到，目的是检测你对”join”方法是否熟悉。这个多线程问题比较简单，可以用join方法实现。
12. **为什么不推荐使用stop和destroy方法来结束线程的运行?**
    
    1.  **destroy**():该方法最初用于破坏该线程，但不作任何资源释放。它所保持的任何监视器都会保持锁定状态。不过，该方法决不会被实现。即使要实现，它也极有可能以 suspend() 方式被死锁。如果目标线程被破坏时保持一个保护关键系统资源的锁，则任何线程在任何时候都无法再次访问该资源。如果另一个线程曾试图锁定该资源，则会出现死锁。
    2.  **stop**():此方法可以强行中止一个正在运行或挂起的线程。但stop方法不安全，就像强行切断计算机电源，而不是按正常程序关机。可能会产生不可预料的结果。
13. Java中如何停止一个线程？  
    Java提供了很丰富的API但没有为停止线程提供API。JDK 1.0本来有一些像stop(), suspend() 和 resume()的控制方法但是由于潜在的死锁威胁因此在后续的JDK版本中他们被弃用了，之后Java API的设计者就没有提供一个兼容且线程安全的方法来停止一个线程。当run() 或者 call() 方法执行完的时候线程会自动结束,如果要手动结束一个线程，你可以用volatile 布尔变量来退出run()方法的循环或者是取消任务来中断线程。
14. 写个代码说明，终止线程的典型方式。
    
    1.   当run()方法执行完后，线程就自动终止了。
    2.  但有些时候run()方法不会结束（如服务器端监听程序），或者其它需要用循环来处理的任务。在这种情况下，一般是将这些任务放在一个循环中，如while循环。如果想让循环永远运行下去，可以使用while（true）\{……\}来处理。但要想使while循环在某一特定条件下退出，最直接的方法就是设一个boolean类型的标志，并通过设置这个标志为true或false来控制while循环是否退出。
15. 一个线程运行时发生异常会怎样？  
    简单的说，**如果异常没有被捕获该线程将会停止执行**。  
    Thread.UncaughtExceptionHandler是用于处理未捕获异常造成线程突然中断情况的一个内嵌接口。当一个未捕获异常将造成线程中断的时候，JVM会使用Thread.getUncaughtExceptionHandler()来查询线程的UncaughtExceptionHandler，并将线程和异常作为参数传递给handler的uncaughtException()方法 进行处理。
16. **下面的代码，实际上有几个线程在运行：**
    
        public static void main(String[] argc) throws Exception {
        
                    Runnable r = new Thread6();
        
                    Thread t = new Thread(r, "Name test");
        
                    t.start();
        
        }
        
        两个：线程t和main()方法（主线程）。

**线程池**：**[Java中的线程池][Java]**  
Executors工具类提供的线程池只需要关注前四种就ok

**线程安全**

1.  Java内存模型是什么？
    
    1.  主内存与工作内存
    2.  内存间交互操作
    3.  对于volatile型变量的特殊规则
    4.  对于long和double型变量的特殊规则
    5.  原子性、可见性与有序性
    6.  先行发生原则
2.  Java中的volatile 变量是什么？
3.  volatile是一个特殊的修饰符，只有成员变量才能使用它。在Java并发程序缺少同步类的情况下，多线程对成员变量的操作对其它线程是透明的。volatile变量可以保证下一个读取操作会在前一个写操作之后发生。
4.  Java中的volatile关键字是什么作用？怎样使用它？在Java中它跟synchronized方法有什么不同？  
    自从Java 5和Java内存模型改变以后，基于volatile关键字的线程问题越来越流行。应该准备好回答关于volatile变量怎样在并发环境中确保可见性、顺序性和一致性。
5.  volatile 变量和 atomic 变量有什么不同？  
    这是个有趣的问题。首先，volatile 变量和 atomic 变量看起来很像，但功能却不一样。Volatile变量可以确保先行关系，即写操作会发生在后续的读操作之前, 但它并不能保证原子性。例如用volatile修饰count变量那么 count++ 操作就不是原子性的。而AtomicInteger类提供的atomic方法可以让这种操作具有原子性如getAndIncrement()方法会原子性 的进行增量操作把当前值加一，其它数据类型和引用变量也可以进行相似操作。  
      
    简单来说， volatile 只解决可见性，不保证同步。  
    atomic 则是保证了可见性 和同步性。内部采用CAS算法实现。
6.  说一下 atomic 的原理？
7.  什么是线程安全？  
    就是能保证共享数据的并发性。
8.  什么是不可变对象，它对写并发应用有什么帮助？  
    另一个多线程经典面试问题，并不直接跟线程有关，但间接帮助很多。这个java面试问题可以变的非常棘手，如果他要求你写一个不可变对象，或者问你为什么String是不可变的。
9.  **Lock和synchronized的选择**  
    总结来说，Lock和synchronized有以下几点不同：
    
    1.  Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；
    2.  lock需要主动释放锁：synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；
    3.  等待可中断：Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。
    4.  读写锁：Lock可以提高多个线程进行读操作的效率。
    5.  公平锁：按照申请锁的时间顺序来依次获得锁
    6.  在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。所以说，在具体使用时要根据适当情况选择。
10. 多线程同步的方式
    
    1.  同步有两种方式，第一种是使用关键字synchronized，第二种是使用接口lock
    2.  对于线程交互，synchnronized有object对象的wait(),notify()和notifyall（）等方法；lock也有相对应的Condition.await（）,Condition.signal()和Condition.signalall（）等方法
    3.  synchronized会死锁，lock也会死锁，但是lock可以使用lock.trylock()尝试获得锁，如果超出设定时间就放弃，而不是一直请求
    4.  synchronized会自动解锁，lock必须手动解锁lock.unlock()
11. Java中的同步集合与并发集合有什么区别？  
    同步集合与并发集合都为多线程和并发提供了合适的线程安全的集合，不过并发集合的可扩展性更高。在Java1.5之前程序员们只有同步集合来用且在 多线程并发的时候会导致争用，阻碍了系统的扩展性。Java5介绍了并发集合像ConcurrentHashMap，不仅提供线程安全还用锁分离和内部分区等现代技术提高了可扩展性。
12. 如何避免死锁？
13. Java中活锁和死锁有什么区别？  
    这是上题的扩展，活锁和死锁类似，不同之处在于处于活锁的线程或进程的状态是不断改变的，活锁可以认为是一种特殊的饥饿。一个现实的活锁例子是两个 人在狭小的走廊碰到，两个人都试着避让对方好让彼此通过，但是因为避让的方向都一样导致最后谁都不能通过走廊。简单的说就是，活锁和死锁的主要区别是前者 进程的状态可以改变但是却不能继续执行。
14. 你如何在Java中获取线程堆栈？  
    对于不同的操作系统，有多种方法来获得Java进程的线程堆栈。当你获取线程堆栈时，JVM会把所有线程的状态存到日志文件或者输出到控制台。  
    在 Windows你可以使用Ctrl + Break组合键来获取线程堆栈，Linux下用kill -3命令。  
    你也可以用jstack这个工具来获取，它对线程id进行操作，你可以用jps这个工具找到id。
15. 你将如何使用thread dump？你将如何分析Thread dump？  
    在UNIX中你可以使用kill -3，然后thread dump将会打印日志，在windows中你可以使用”CTRL+Break”。非常简单和专业的线程面试问题，但是如果他问你怎样分析它，就会很棘手。 
16. JVM中哪个参数是用来控制线程的堆栈大小的  
    这个问题很简单， -Xss参数用来控制线程的堆栈大小。
17. Java中ConcurrentHashMap的并发度是什么？  
    ConcurrentHashMap把实际map划分成若干部分来实现它的可扩展性和线程安全。这种划分是使用并发度获得的，它是 ConcurrentHashMap类构造函数的一个可选参数，默认值为16，这样在多线程情况下就能避免争用。
18. Java中的ReadWriteLock是什么？  
    一般而言，读写锁是用来提升并发程序性能的锁分离技术的成果。Java中的ReadWriteLock是Java 5 中新增的一个接口，一个ReadWriteLock维护一对关联的锁，一个用于只读操作一个用于写。在没有写线程的情况下一个读锁可能会同时被多个读线程 持有。写锁是独占的，你可以使用JDK中的ReentrantReadWriteLock来实现这个规则，它最多支持65535个写锁和65535个读 锁。
19. 多线程中的忙循环是什么?  
    忙循环就是程序员用循环让一个线程等待，不像传统方法wait(), sleep() 或 yield() 它们都放弃了CPU控制，而忙循环不会放弃CPU，它就是在运行一个空循环。这么做的目的是为了保留CPU缓存，在多核系统中，一个等待线程醒来的时候可能会在另一个内核运行，这样会重建缓存。为了避免重建缓存和减少等待重建的时间就可以使用它了。
20. 如果同步块内的线程抛出异常会发生什么？  
    这个问题坑了很多Java程序员，若你能想到锁是否释放这条线索来回答还有点希望答对。无论你的同步块是正常还是异常退出的，里面的线程都会释放锁，所以对比锁接口我更喜欢同步块，因为它不用我花费精力去释放锁，该功能可以在[finally block][]里释放锁实现。
21. 单例模式的双检锁是什么？  
    这个问题在Java面试中经常被问到，但是面试官对回答此问题的满意度仅为50%。一半的人写不出双检锁还有一半的人说不出它的隐患和 Java1.5是如何对它修正的。它其实是一个用来创建线程安全的单例的老方法，当单例实例第一次被创建时它试图用单个锁进行性能优化，但是由于太过于复 杂在JDK1.4中它是失败的，我个人也不喜欢它。无论如何，即便你也不喜欢它但是还是要了解一下，因为它经常被问到。
22.  如何在Java中创建线程安全的Singleton？  
    这是上面那个问题的后续，如果你不喜欢双检锁而面试官问了创建Singleton类的替代方法，你可以利用JVM的类加载和静态变量初始化特征来创建Singleton实例，或者是利用枚举类型来创建Singleton，我很喜欢用这种方法。
23. 写出3条你遵循的多线程最佳实践  
    这种问题我最喜欢了，我相信你在写并发代码来提升性能的时候也会遵循某些最佳实践。以下三条最佳实践我觉得大多数Java程序员都应该遵循：
    
    1.  给你的线程起个有意义的名字。  
        这样可以方便找bug或追踪。OrderProcessor, QuoteProcessor or TradeProcessor 这种名字比 Thread-1. Thread-2 and Thread-3 好多了，给线程起一个和它要完成的任务相关的名字，所有的主要框架甚至JDK都遵循这个最佳实践。
    2.  避免锁定和缩小同步的范围  
        锁花费的代价高昂且上下文切换更耗费时间空间，试试最低限度的使用同步和锁，缩小临界区。因此相对于同步方法我更喜欢同步块，它给我拥有对锁的绝对控制权。
    3.  多用同步类少用wait 和 notify  
        首先，CountDownLatch, Semaphore, CyclicBarrier 和 Exchanger 这些同步类简化了编码操作，而用wait和notify很难实现对复杂控制流的控制。其次，这些类是由最好的企业编写和维护在后续的JDK中它们还会不断 优化和完善，使用这些更高等级的同步工具你的程序可以不费吹灰之力获得优化。
    4.  多用并发集合少用同步集合  
        这是另外一个容易遵循且受益巨大的最佳实践，并发集合比同步集合的可扩展性更好，所以在并发编程时使用并发集合效果更好。如果下一次你需要用到map，你应该首先想到用ConcurrentHashMap。
24. 如何强制启动一个线程？  
    这个问题就像是如何强制进行Java垃圾回收，目前还没有觉得方法，虽然你可以使用System.gc()来进行垃圾回收，但是不保证能成功。在Java里面没有办法强制启动一个线程，它是被线程调度器控制着且Java没有公布相关的API。
25. 在Java中Lock接口比synchronized块的优势是什么？你需要实现一个高效的缓存，它允许多个用户读，但只允许一个用户写，以此来保持它的完整性，你会怎样去实现它？  
    |lock接口在多线程和并发编程中最大的优势是它们为读和写分别提供了锁，它能满足你写像ConcurrentHashMap这样的高性能数据结构和有条件的阻塞。Java线程面试的问题越来越会根据面试者的回答来提问。我强烈建议在你去参加多线程的面试之前认真读一下Locks，因为当前其大量用于构建电子交易终统的客户端缓存和交易连接空间。
26. 用Java编程一个会导致死锁的程序，你将怎么解决？
27. 这是我最喜欢的Java线程面试问题，因为即使死锁问题在写多线程并发程序时非常普遍，但是很多侯选者并不能写deadlock free code（无死锁代码？），他们很挣扎。只要告诉他们，你有N个资源和N个线程，并且你需要所有的资源来完成一个操作。为了简单这里的n可以替换为2，越大的数据会使问题看起来更复杂。通过避免Java中的死锁来得到关于死锁的更多信息。
28.  什么是原子操作，Java中的原子操作是什么？  
    JDK6 以后，新增加了一个包java.util.concurrent.atomic，里面有各种原子类，比如AtomicInteger。  
    而AtomicInteger提供了各种自增，自减等方法，这些方法都是原子性的。 换句话说，自增方法 incrementAndGet 是线程安全的，同一个时间，只有一个线程可以调用这个方法。
29. 什么是竞争条件？你怎样发现和解决竞争？  
    这是一道出现在多线程面试的高级阶段的问题。大多数的面试官会问最近你遇到的竞争条件，以及你是怎么解决的。有些时间他们会写简单的代码，然后让你检测出代码的竞争条件。可以参考我之前发布的关于Java竞争条件的文章。在我看来这是最好的java线程面试问题之一，它可以确切的检测候选者解决竞争条件的经验，or writing code which is free of data race or any other race condition。关于这方面最好的书是《Concurrency practices in Java》。
30. Java中你怎样唤醒一个阻塞的线程？  
    这是个关于线程和阻塞的棘手的问题，它有很多解决方法。如果线程遇到了IO阻塞，我并且不认为有一种方法可以中止线程。如果线程因为调用wait()、sleep()、或者join()方法而导致的阻塞，你可以中断线程，并且通过抛出InterruptedException来唤醒它。我之前写的《How to deal with blocking methods in java》有很多关于处理线程阻塞的信息。
31. 你在多线程环境中遇到的共同的问题是什么？你是怎么解决它的？  
    多线程和并发程序中常遇到的有Memory-interface、竞争条件、死锁、活锁和饥饿。问题是没有止境的，如果你弄错了，将很难发现和调试。这是大多数基于面试的，而不是基于实际应用的Java线程问题。
32. 补充的其它几个问题：
    
    1.  Java中用到的线程调度算法是什么？  
        抢占式。一个线程用完CPU之后，操作系统会根据线程优先级、线程饥饿情况等数据算出一个总的优先级并分配下一个时间片给某个线程执行。  
        操作系统中可能会出现某条线程常常获取到VPU控制权的情况，为了让某些优先级比较低的线程也能获取到CPU控制权，可以使用Thread.sleep(0)手动触发一次操作系统分配时间片的操作，这也是平衡CPU控制权的一种操作。
    2.  在线程中你怎么处理不可捕捉异常？  
        在java中要捕捉多线程产生的异常，需要自定义异常处理器，并设定到对应的线程工厂中
    3.  为什么使用Executor框架比使用应用创建和管理线程好？
    4.  在Java中Executor和Executors的区别？
        
        1.  Executor 接口对象能执行我们的线程任务；
        2.  Executors 工具类的不同方法按照我们的需求创建了不同的线程池，来满足业务的需求。
        3.  ExecutorService 接口继承了Executor接口并进行了扩展，提供了更多的方法，我们能够获得任务执行的状态并且可以获取任务的返回值。
    5.  如何在Windows和Linux上查找哪个线程使用的CPU时间最长？

[Java]: https://www.cnblogs.com/funyoung/p/10530986.html
[finally block]: http://javarevisited.blogspot.com/2012/11/difference-between-final-finally-and-finalize-java.html