【问答篇】Java 线程篇面试题（二）

每天进步一点~

(ps: 文章内容及图片出处来自本人公众号~)

01、问：请谈谈你对线程声明周期的6种状态的认识和理解

答：很多地方说线程有5种状态，但实际上是6种状态:NEW、RUNNABLE, BLOCKED、 WAITING、TIMED_WAITING、TERMINATED;

新创建：又称初始化状态，这个时候Thread才刚刚被new出来，还没有被启动。

可运行状态：表示已经调用Thread的start方法启动了，随时等待CPU的调度，此状态又被称为就绪状态。

被终止：死亡状态，表示已经正常执行完线程体run()中的方法了或者因为没有捕获的异常而终止run()方法了。

计时状态：调用sleep(参数)或wait(参数)后线程进入计时状态，睡眠时间到了或wait时间到了，再或者其它线程调用notify并获取到锁之后开始进入可运行状态。另一种情况，其它线程调用notify没有获取到锁或者wait时间到没有获取到锁时，进入堵塞状态。

无线等待状态：获取锁对象后，调用wait()方法，释放锁进入无线等待状态。

锁堵塞状态：wait(参数)时间到或者其它线程调用notify后没有获取到锁对象都会进入堵塞状态，只要一获取到锁对象就会进入可运行状态。

ps:堵塞状态的详解：

02、问：请问Java用到的线程调度算法是什么？

答：计算机通常只有一个CPU，在任意时刻只能执行一条机器指令，每个线程只有获取到CPU的使用权才能执行指令，所谓多线程的并发运行，其实从宏观上看，各线程轮流获取CPU的使用权，分别执行各自的任务。在运行池中，会有多个处于就绪状态的线程在等待，CPU的调度，JVM有一项任务就是负责CPU的调度，线程调度就是按照特定的机制为多个线程分配CPU的使用权。

有两种调度模型：分时调度和抢占式调度

分时调度：就是让所有的线程轮流获得CPU的使用权，并且平均分配到各个线程占有CPU的时间片。

抢占式调度：Java虚拟机采用抢占式调度模型，是指优先让线程池中优先级高的线程首先占用CPU，如果线程池中优先级相同，那么随机选择一个线程，使其占有CPU，处于这个状态的CPU会一直运行，优先级高的分的CPU的时间片相对会多一点。

03、问：请谈谈你对Java线程调度策略的认识和理解？

答：线程调度优先选择优先级高的运行，但是如果出现一下情况，就会终止运行(不是进入死亡状态)：

1.线程调用了yield方法让出CPU的使用权，线程进入就绪状态。

2.线程调用sleep()方法，使其进入计时状态

3.线程由于IO受阻

4.另一个更高的优先级线程出现

5.在支持的时间片系统中，改线程的时间片用完。

04、问：请问什么是线程调度(Thread Scheduler)和时间分片(Time Slicing)？

答：

线程调度是一个操作系统服务，它负责为储在Runnable状态的线程分配CPU时间片，一旦我们创建一个线程并启动它，它的执行便依赖线程调度器的实现。
时间分片是指CPU可用时间分配给Runnable的过程，分配的时间可以根据线程优先级或线程等待时间。

05、问：请讲一下Java线程同步和线程调度的相关方法？

答：

1.wait()：调用后线程进入无限等待状态，并释放所持对象的锁

2.sleep()：使一个线程进入休眠状态（堵塞状态），带有对象锁，是一个静态方法，需要处理InterruptException异常。

3.notify()：唤醒一个处于等待状态的线程(无线等待或计时等待)，如果多个线程在等待，并不能确切的唤醒一个线程，与JVM确定唤醒那个线程，与其优先级有关。

4.notityAll()：唤醒所有处于等待状态的线程，但是并不是将对象的锁给所有的线程，而是让它们去竞争，谁先获取到锁，谁先进入就绪状态。

06、问：请问sleep()和wait()有什么区别呢?

答：两者都可以使线程进入等待状态

类不同：sleep()是Thread下的静态方法,wait()是Object类下的方法

是否释放锁：sleep()不释放锁，wait()释放锁

用处不同：wait()常用于线程间的通信，sleep()常用于暂停执行。

用法不同：wait()用完后，线程不会自动执行，必须调用notify()或notifyAll()方法才能执行，sleep()方法调用后，线程经过过一定时间会自动苏醒，wait(参数)也可以传参数使其苏醒。它们苏醒后还有所区别，因为wait(）会释放锁，所以苏醒后没有获取到锁就进入堵塞状态，获取到锁就进入就绪状态，而sleep苏醒后之间进入就绪状态，但是如果cpu不空闲，则进入的是就绪状态的堵塞队列中。

07、问：请问你是如何调用wait()方法的，使用if还是循环?

答：处以等待状态的线程可能会收到错误警告或伪唤醒，如果不在循环中检查等待条件，程序可能会在没有满足条件的时候退出。

synchronized(monitor){    
//  判断条件谓词是否得到满足    
    while(!locked){
        //  等待唤醒        
        monitor.wait();    
    }    
//  处理其他的业务逻辑
}

08、问：为什么线程通信方法wait(),notify(),notifyAll()要被定义到Object类中呢？

答：Java中任何对象都可以被当作锁对象，wait(),notify(),notifyAll()方法用于等待获取唤醒对象去获取锁，Java中没有提供任何对象使用的锁，但是任何对象都继承于Object类，所以定义在Object类中最合适。

有人会说，既然是线程放弃对象锁，那也可以把wait()放到Thread类中，新定义线程继承Thread类，也无需重新定义wait()，
然而，这样做有一个很大的问题，因为一个线程可以持有多把锁，你放弃一个线程时，到底要放弃哪把锁，当然了这种设计不能不能实现，只是管理起来比较麻烦。

综上：wait(),notify(),notifyAll()应该要被定义到Object类中。

09、问：为什么线程通信方法wait(),notify(),notifyAll()要在同步代码块或同步方法中被调用呢？

答：wait(),notify(),notifyAll()方法都有一个特点，就是对象去调用它们的时候必须持有锁对象。

如对象调用wait()方法后持有的锁对象就释放出去，等待下一个线程来获取。
如对象调用notifyAll()要唤醒等待中的线程，也要讲自身用于的锁对象释放，让就绪状态中的线程竞争获取锁。
由于这些方法都需要线程持有锁对象，这样只能通过同步来实现，所以它们只能在同步块或同步方法中被调用。

10、问：请问Thread的yield方法有什么作用？

答：让出CPU的使用权，使当前线程从运行状态进入就绪状态，等待CPU的下次调度。

11、问：请问为什么Thread的sleep和yield是静态的？

答：Thread类的sleep()和yield()方法将在当前正在运行的线程上工作，所以其它处于等待状态的线程调用它们是没有意义的，所以设置为静态最合适。

12、问：请问线程sleep和yield方法有什么区别呢？

答：

1.线程调用sleep()方法进入堵塞状态，醒来后因为(没有释放锁)后直接进入了就绪状态，运行yield后也没有释放锁，于是进入了就绪状态。

2.sleep()方法使用时需要处理InterruptException异常，而yield没有。

3.sleep()执行后进入堵塞状态(计时等待)，醒来后进入就绪状态(可能是堵塞队列)，而yield是直接进入就绪状态。

13、问：请问如何停止一个正在运行的线程？

答：

1.使用stop方法终止，但是这个方法已经过期，不被推荐使用。

2.使用interrupt方法终止线程

3.run方法执行结束，正常退出

14、问：请问如何在两个线程间共享数据？

答：两个线程之间共享变量即可实现共享数据。

一般来说，共享变量要求变量本身是线程安全的，然后在线程中对变量使用。

15、问：同步代码块和同步方法怎么选？

答：同步块是更好的选择，因为它不会锁着整个对象，当然你也可以使它锁住整个对象。同步方法会锁住整个对象，哪怕这个类中有不关联的同步块，这通常会导致停止继续执行，并等待获取这个对象锁。

同步块扩展性比较好，只需要锁住代码块里面相应的对象即可，可以避免死锁的产生。
原则：同步范围也小越好。

16、问：请问什么是线程安全？Servlet是线程安全吗？

答：线程安全是指某个方法在多线程的环境下被调用时，能够正确处理多线程之间的共享变量，程序能够正确完成。

Servlet不是线程安全的，它是单实例多线程的，当多个线程同时访问一个方法时，不能保证共享变量是安全的。
Struts2是多实例多线程的，线程安全，每个请求过来都会new一个新的action分配这个请求，请求完成后销毁。
springMVC的controller和Servlet一样，属性单实例多线程的，不能保证共享变量是安全的。
Struts2好处是不用考虑线程安全问题，springMVC和Servlet需要考虑。
如果想既可以提升性能又可以不能管理多个对象的话建议使用ThreadLocal来处理多线程。

17、问：请问线程的构造方法，静态块是被哪个线程类调用的？

答：该线程在哪个类中被new出来，就是在哪个被哪个类调用，而run方法是线程类自身调用的。例子：mian函数中new Thread2，Thread2中new Thread1

thread1线程的构造方法，静态块是thread2线程调用的，run方法是thread1调用的。
thread2线程的构造方法，静态块是main线程调用的，run方法是thread2调用的。

18、问：请问Java中是如何保证多线程安全的？

答：

使用安全类，比如 java.util.concurrent 下的类，使用原子类AtomicInteger
使用自动锁，synchronized锁
Lock lock = new ReentrantLock()，使用手动锁lock .lock()，lock.unlock()方法

19、问：请回答线程同步和线程互斥的区别？

答：

线程同步：

当一个线程对共享数据进行操作的时候，在没有完成相关操作时，不允许其它的线程来打断它，否则就会破坏数据的完整性，必然会引起错误信息，这就是线程同步。

线程互斥：

而线程互斥是站在共享资源的角度上看问题，例如某个共享资源规定，在某个时刻只能一个线程来访问我，其它线程只能等待，直到占有的资源者释放该资源，线程互斥可以看作是一种特殊的线程同步。

实现线程同步的方法：

1.同步代码块：sychronized(对象){} 块
2.同步方法：sychronized修饰的方法
3.使用重入锁实现线程同步：reentrantlock类的锁又互斥功能，Lock lock = new ReentrantLock(); Lock对象的ock和unlock为其加锁

20、问：你对线程的优先级有什么理解吗？

答：

每个线程都具有优先级的，一般来说，高优先级的在线程调度时会具有优先被调用权。我们可以自定义线程的优先级，但这并不能保证高优先级又在低优先级前被调用，只是说概率有点大。
线程优先级是1-10，1代表最低，10代表最高。
Java的线程优先级调度会委托操作系统来完成，所以与具体的操作系统优先级也有关，所以如非特别需要，一般不去修改优先级。

21、问：请谈谈你对乐观锁和悲观锁的理解？

答：

乐观锁：

每个去拿数据的时候都认为别人不会修改，所以不会都不会上锁，但是在更新的时候会判断一下在此期间有没有去更新这个数据。所以乐观锁使用了多读的场合，这样可以提高吞吐量，像数据库提供的类似write_condition机制，都是用的乐观锁，还有那个原子变量类，在java.util.concurrent.atomic包下

悲观锁：

总是假设最坏的情况，每次去拿数据的时候都会认为有人会修改，所以每次在拿数据的时候都会上锁。这样别的对象想拿到数据，那就必须堵塞，直到拿到锁。传统的关系型数据库用到了很多这种锁机制，比如读锁，写锁，在操作之前都会先上锁，再比如Java的同步代码块synchronized/方法用的也是悲观锁。

Thanks~