Java线程面试题有哪些

本篇内容主要讲解“Java线程面试题有哪些”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“Java线程面试题有哪些”吧!

Java 关键字volatile 与 synchronized 作用与区别？

JVM中存在一个主存区（Main Memory或Java Heap Memory），Java中所有变量都是存在主存中的，对于所有线程进行共享，

而每个线程又存在自己的工作内存（Working Memory），工作内存中保存的是主存中某些变量的拷贝，

线程对所有变量的操作并非发生在主存区，

而是发生在工作内存中，而线程之间是不能直接相互访问，变量在程序中的传递，是依赖主存来完成的。

在java中可以实现可见性的两个关键字 

 1)使用关键字synchronized

 2)使用关键字volatile

 Synchronized能够实现多线程的原子性(同步)和可见性。

JVM关于Synchronized的两条规定：

1)线程解锁前，必须把共享变量的最新值刷新到主内存中。

2)线程加锁时，将清空工作内存中共享变量的值，从而使用共享变量时需要从主内存中重新读取最新的值(注意：加锁和解锁需要同一把锁)。

volatile可以保证变量的可见性，但是不能保证复合操作的原子性

volatile如何实现内存可见性？

深入来说：通过加入内存屏障和禁止重排序优化来实现的。

1)对volatile变量执行写操作时，会在写操作后加入一条store屏障指令。

2)对volatile变量执行读操作时，会在读操作后加入一条load屏障指令。

通俗地讲：volatile变量在每次被线程访问时，都强迫从主内存中重读该变量的值，而当该变量发生变化时，又会强迫线程将最新的值刷新到主内存，这样任何时刻，不同的线程总能看到该变量的最新值。

线程写volatile变量的过程：

1)改变线程工作内存中volatile变量副本的值。

2)将改变后的副本的值从工作内存刷新到主内存。

线程读volatile变量的过程：

1)从主内存中读取volatile变量的最新值到线程的工作内存中。

2)从工作内存中读取volatile变量的副本

volatile不能保证volatile变量复合操作的原子性

对于下面的一段程序的使用volatile和synchronized

private int number = 0;              

number++;//不是原子操作                   

1读取number的值                      

2将number的值加1                    

3写入最新的number的值  

//加入synchronized，变为原子操作   

synchronized(thhis){ 

        number++; 

}

//变为volatile变量，无法保证原子性

private volatile int number = 0;

volatile变量可用于提供线程安全，但是只能应用于非常有限的一组用例：多个变量之间或者某个变量的当前值与修改后值之间没有约束。因此，单独使用 volatile 还不足以实现计数器、互斥锁或任何具有与多个变量相关的不变式（Invariants）的类（例如 “start <=end”）。

出于简易性或可伸缩性的考虑，您可能倾向于使用 volatile 变量而不是锁。当使用 volatile 变量而非锁时，某些习惯用法（idiom）更加易于编码和阅读。此外，volatile 变量不会像锁那样造成线程阻塞，因此也很少造成可伸缩性问题。在某些情况下，如果读操作远远大于写操作，volatile 变量还可以提供优于锁的性能优势。

volatile适合的使用场景

只能在有限的一些情形下使用 volatile 变量替代锁。要使 volatile 变量提供理想的线程安全，必须同时满足下面两个条件：

（1）对变量的写入操作不依赖其当前值

（2）该变量没有包含在具有其他变量的不变式中。

第一个条件的限制使 volatile 变量不能用作线程安全计数器。虽然增量操作（x++）看上去类似一个单独操作，实际上它是一个由（读取－修改－写入）操作序列组成的组合操作，必须以原子方式执行，而 volatile 不能提供必须的原子特性。实现正确的操作需要使x 的值在操作期间保持不变，而 volatile 变量无法实现这点。（然而，如果只从单个线程写入，那么可以忽略第一个条件。）

总结：

1)volatile比synchronized更轻量级。

2)volatile没有synchronized使用的广泛。

3)volatile不需要加锁，比synchronized更轻量级，不会阻塞线程。

4)从内存可见性角度看，volatile读相当于加锁，volatile写相当于解锁。

5)synchronized既能保证可见性，又能保证原子性，而volatile只能保证可见性，无法保证原子性。

6)volatile本身不保证获取和设置操作的原子性，仅仅保持修改的可见性。但是java的内存模型保证声明为volatile的long和double变量的get和set操作是原子的。

注意:

对64位(long、double)变量的读写可能不是原子操作

Java内存模型允许JVM将没有被volatile修饰的64位数据类型的读写操作划分为两次32位的读写操作来运行。

导致问题：有可能会出现读取到半个变量的情况。

解决方法：加volatile关键字。

一个问题：即使没有保证可见性的措施，很多时候共享变量依然能够在主内存和工作内存间得到及时的更新？

        答：一般只有在短时间内高并发的情况下才会出现变量得不到及时更新的情况，因为CPU在执行时会很快地刷新缓存，

所以一般情况下很难看到这种问题。慢了不就不会刷新了。CPU运算快的话，在分配的时间片内就能完成所有工作：

工作内从1->主内存->工作内存2，

这样一来就保证了数据的可见性。在这个过程中，假如线程没有在规定时间内完成工作，然后这个线程就释放CPU，分配给其它线程，

该线程就需要等待CPU下次给该线程分配时间片，如果在这段时间内有别的线程访问共享变量，可见性就没法保证了。

什么是ThreadLocal变量？

ThreadLocal使用场合主要解决多线程中数据数据因并发产生不一致问题。

ThreadLocal为每个线程的中并发访问的数据提供一个副本，通过访问副本来运行业务，

这样的结果是耗费了内存，单大大减少了线程同步所带来性能消耗，也减少了线程并发控制的复杂度。

Spring使用ThreadLocal解决线程安全问题。通常只有无状态的Bean才可以在多线程环境下共享，

在Spring中，绝大部分Bean都可以声明为singleton作用域。就是因为Spring对一些Bean（如RequestContextHolder、TransactionSynchronizationManager、LocaleContextHolder等）中非线程安全的“状态性对象”采用ThreadLocal进行封装，

让它们也成为线程安全的“状态性对象”，

因此有状态的Bean就能够以singleton的方式在多线程中正常工作了。

一般的Web应用划分为控制层、服务层和持久层三个层次，在不同的层中编写对应的逻辑

，下层通过接口向上层开放功能调用。在一般情况下，从接收请求到返回响应所经过的所有程序调用都同属于一个线程。

这样用户就可以根据需要，将一些非线程安全的变量以ThreadLocal存放，

在同一次请求响应的调用线程中，

所有对象所访问的同一ThreadLocal变量都是当前线程所绑定的。

Thread类有一个类型为ThreadLocal.ThreadLocalMap的实例变量threadLocals，也就是说每个线程有一个自己的ThreadLocalMap。

ThreadLocalMap有自己的独立实现，可以简单地将它的key视作ThreadLocal，value为代码中放入的值（实际上key并不是ThreadLocal本身，而是它的一个弱引用）。

每个线程在往ThreadLocal里放值的时候，都会往自己的ThreadLocalMap里存，读也是以ThreadLocal作为引用，在自己的map里找对应的key，从而实现了线程隔离。

ThreadLocalMap有点类似HashMap的结构，只是HashMap是由数组+链表实现的，而ThreadLocalMap中并没有链表结构。

我们还要注意Entry， 它的key是ThreadLocal<?> k ，继承自WeakReference， 也就是我们常说的弱引用类型。.

为了搞清楚这个问题，我们需要搞清楚Java的四种引用类型：

强引用：我们常常new出来的对象就是强引用类型，只要强引用存在，垃圾回收器将永远不会回收被引用的对象，哪怕内存不足的时候

软引用：使用SoftReference修饰的对象被称为软引用，软引用指向的对象在内存要溢出的时候被回收

弱引用：使用WeakReference修饰的对象被称为弱引用，只要发生垃圾回收，若这个对象只被弱引用指向，那么就会被回收

虚引用：虚引用是最弱的引用，在 Java 中使用 PhantomReference 进行定义。虚引用中唯一的作用就是用队列接收对象即将死亡的通知.

这个问题刚开始看，如果没有过多思考，弱引用，还有垃圾回收，那么肯定会觉得是null。

其实是不对的，因为题目说的是在做 threadlocal.get() 操作，证明其实还是有强引用存在的，所以 key 并不为 null，如下图所示，ThreadLocal的强引用仍然是存在的

如果我们的强引用不存在的话，那么 key 就会被回收，也就是会出现我们 value 没被回收，key 被回收，导致 value 永远存在，出现内存泄漏。

HashMap中解决冲突的方法是在数组上构造一个链表结构，冲突的数据挂载到链表上，如果链表长度超过一定数量则会转化成红黑树。

而ThreadLocalMap中并没有链表结构，所以这里不能适用HashMap解决冲突的方式了。

如果我们插入一个value=27的数据，通过hash计算后应该落入第4个槽位中，而槽位4已经有了Entry数据。

此时就会线性向后查找，一直找到Entry为null的槽位才会停止查找，将当前元素放入此槽位中。当然迭代过程中还有其他的情况，比如遇到了Entry不为null且key值相等的情况，还有Entry中的key值为null的情况等等都会有不同的处理，后面会一一详细讲解。

这里还画了一个Entry中的key为null的数据（Entry=2的灰色块数据），因为key值是弱引用类型，所以会有这种数据存在。在set过程中，如果遇到了key过期的Entry数据，实际上是会进行一轮探测式清理操作的，具体操作方式后面会讲到

 实际的通过ThreadLocal创建的副本是存储在每个线程自己的threadLocals中的；

为何threadLocals的类型ThreadLocalMap的键值为ThreadLocal对象，因为每个线程中可有多个threadLocal变量，就像上面代码中的longLocal和stringLocal；

ThreadLocal和Synchonized都用于解决多线程并发访问。但是ThreadLocal与synchronized有本质的区别。synchronized是利用锁的机制，

使变量或代码块在某一时该只能被一个线程访问。而ThreadLocal为每一个线程都提供了变量的副本，

使得每个线程在某一时间访问到的并不是同一个对象，这样就隔离了多个线程对数据的数据共享。而Synchronized却正好相反，它用于在多个线程间通信时能够获得数据共享

如何在Java中实现线程？

在语言层面有三种方式。java.lang.Thread 类的实例就是一个线程但是它需要调用java.lang.Runnable接口来执行，

由于线程类本身就是调用的Runnable接口所以你可以继承 java.lang.Thread 类或者直接调用Runnable接口来重写run()方法实现线程。

第三种 实现Callable<>接口并重写call方法

Java中Runnable和Callable有什么不同？

Runnable和Callable都代表那些要在不同的线程中执行的任务。

Runnable从JDK1.0开始就有了，Callable是在 JDK1.5增加的。

它们的主要区别是Callable的 call() 方法可以返回值和抛出异常，而Runnable的run()方法没有这些功能。

Callable可以返回装载有计算结果的Future对象

什么是线程安全？Vector是一个线程安全类吗？

如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，

而且其他的变量 的值也和预期的是一样的，就是线程安全的。一个线程安全的计数器类的同一个实例对象在被多个线程使用的情况下也不会出现计算失误。

很显然你可以将集合类分 成两组，线程安全和非线程安全的。Vector 是用同步方法来实现线程安全的, 而和它相似的ArrayList不是线程安全的。

Java中notify 和 notifyAll有什么区别？

这又是一个刁钻的问题，因为多线程可以等待单监控锁，Java API 的设计人员提供了一些方法当等待条件改变的时候通知它们，但是这些方法没有完全实现。

notify()方法不能唤醒某个具体的线程，所以只有一个线程在等 待的时候它才有用武之地。

而notifyAll()唤醒所有线程并允许他们争夺锁确保了至少有一个线程能继续运行。

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

这是个设计相关的问题，它考察的是面试者对现有系统和一些普遍存在但看起来不合理的事物的看法。回答这些问题的时候，

你要说明为什么把这些方法放在 Object类里是有意义的，还有不把它放在Thread类里的原因。一个很明显的原因是JAVA提供的锁是对象级的而不是线程级的，

每个对象都有锁，通 过线程获得。如果线程需要等待某些锁那么调用对象中的wait()方法就有意义了。

如果wait()方法定义在Thread类中，线程正在等待的是哪个锁 就不明显了。简单的说，

由于wait，notify和notifyAll都是锁级别的操作，所以把他们定义在Object类中因为锁属于对象。

什么是FutureTask？

在Java并发程序中FutureTask表示一个可以取消的异步运算。它有启动和取消运算、查询运算是否完成和取回运算结果等方法。

只有当运算完 成的时候结果才能取回，如果运算尚未完成get方法将会阻塞。一个FutureTask对象可以对调用了Callable和Runnable的对象进行包 装，

由于FutureTask也是调用了Runnable接口所以它可以提交给Executor来执行。

有哪些不同的线程生命周期？

        当我们在Java程序中新建一个线程时，它的状态是New。当我们调用线程的start()方法时，

状态被改变为Runnable。线程调度器会为Runnable线程池中的线程分配CPU时间并且讲它们的状态改变为Running。

什么是死锁(Deadlock)？如何分析和避免死锁？

        死锁是指两个以上的线程永远阻塞的情况，这种情况产生至少需要两个以上的线程和两个以上的资源。

        分析死锁，我们需要查看Java应用程序的线程转储。我们需要找出那些状态为BLOCKED的线程和他们等待的资源。每个资源都有一个唯一的id，用这个id我们可以找出哪些线程已经拥有了它的对象锁。

        避免嵌套锁，只在需要的地方使用锁和避免无限期等待是避免死锁的通常办法其他的线程状态还有Waiting，Blocked 和Dead。

到此，相信大家对“Java线程面试题有哪些”有了更深的了解，不妨来实际操作一番吧！这里是亿速云网站，更多相关内容可以进入相关频道进行查询，关注我们，继续学习！