/
Java 线程面试问题
在任何Java面试当中多线程和并发方面的问题都是必不可少的一部分。如果你想获得任何股票投资银行的前台资讯职位，那么你应该准备很多关于多线程的问题。在投资银行业务中多线程和并发是一个非常受欢迎的话题，特别是电子交易发展方面相关的。他们会问面试者很多令人混淆的Java线程问题。面试官只是想确信面试者有足够的Java线程与并发方面的知识，因为候选人中有很多只浮于表面。用于直接面向市场交易的高容量和低延时的电子交易系统在本质上是并发的。下面这些是我在不同时间不同地点喜欢问的Java线程问题。我没有提供答案，但只要可能我会给你线索，有些时候这些线索足够回答问题。现在引用Java5并发包关于并发工具和并发集合的问题正在增多。那些问题中ThreadLocal、Blocking Queue、Counting Semaphore和ConcurrentHashMap比较流行。
15个Java多线程面试题及回答
1)现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行？
这个线程问题通常会在第一轮或电话面试阶段被问到，目的是检测你对”join”方法是否熟悉。这个多线程问题比较简单，可以用join方法实现。
2)在Java中Lock接口比synchronized块的优势是什么？你需要实现一个高效的缓存，它允许多个用户读，但只允许一个用户写，以此来保持它的完整性，你会怎样去实现它？
lock接口在多线程和并发编程中最大的优势是它们为读和写分别提供了锁，它能满足你写像ConcurrentHashMap这样的高性能数据结构和有条件的阻塞。Java线程面试的问题越来越会根据面试者的回答来提问。我强烈建议在你去参加多线程的面试之前认真读一下Locks，因为当前其大量用于构建电子交易终统的客户端缓存和交易连接空间。
3)在java中wait和sleep方法的不同？
通常会在电话面试中经常被问到的Java线程面试问题。最大的不同是在等待时wait会释放锁，而sleep一直持有锁。Wait通常被用于线程间交互，sleep通常被用于暂停执行。
4）用Java实现阻塞队列。
这是一个相对艰难的多线程面试问题，它能达到很多的目的。第一，它可以检测侯选者是否能实际的用Java线程写程序；第二，可以检测侯选者对并发场景的理解，并且你可以根据这个问很多问题。如果他用wait()和notify()方法来实现阻塞队列，你可以要求他用最新的Java 5中的并发类来再写一次。
5）用Java写代码来解决生产者——消费者问题。
与上面的问题很类似，但这个问题更经典，有些时候面试都会问下面的问题。在Java中怎么解决生产者——消费者问题，当然有很多解决方法，我已经分享了一种用阻塞队列实现的方法。有些时候他们甚至会问怎么实现哲学家进餐问题。
6）用Java编程一个会导致死锁的程序，你将怎么解决？
这是我最喜欢的Java线程面试问题，因为即使死锁问题在写多线程并发程序时非常普遍，但是很多侯选者并不能写deadlock free code（无死锁代码？），他们很挣扎。只要告诉他们，你有N个资源和N个线程，并且你需要所有的资源来完成一个操作。为了简单这里的n可以替换为2，越大的数据会使问题看起来更复杂。通过避免Java中的死锁来得到关于死锁的更多信息。
7) 什么是原子操作，Java中的原子操作是什么？
非常简单的java线程面试问题，接下来的问题是你需要同步一个原子操作。
8) Java中的volatile关键是什么作用？怎样使用它？在Java中它跟synchronized方法有什么不同？
自从Java 5和Java内存模型改变以后，基于volatile关键字的线程问题越来越流行。应该准备好回答关于volatile变量怎样在并发环境中确保可见性、顺序性和一致性。
———————————–
Java 关键字volatile 与 synchronized 作用与区别
1，volatile
它所修饰的变量不保留拷贝，直接访问主内存中的。
在Java内存模型中，有main memory，每个线程也有自己的memory (例如寄存器)。为了性能，一个线程会在自己的memory中保持要访问的变量的副本。这样就会出现同一个变 量在某个瞬间，在一个线程的memory中的值可能与另外一个线程memory中的值，或者main memory中的值不一致的情况。 一个变量声明为volatile，就意味着这个变量是随时会被其他线程修改的，因此不能将它cache在线程memory中。
2，synchronized
当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。
一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。
三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。
四、当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。
五、以上规则对其它对象锁同样适用.
区别：
一、volatile是变量修饰符，而synchronized则作用于一段代码或方法。
二、volatile只是在线程内存和“主”内存间同步某个变量的值；而synchronized通过锁定和解锁某个监视器同步所有变量的值。显然synchronized要比volatile消耗更多资源
————————————————————————————————–
9) 什么是竞争条件？你怎样发现和解决竞争？
这是一道出现在多线程面试的高级阶段的问题。大多数的面试官会问最近你遇到的竞争条件，以及你是怎么解决的。有些时间他们会写简单的代码，然后让你检测出代码的竞争条件。可以参考我之前发布的关于Java竞争条件的文章。在我看来这是最好的java线程面试问题之一，它可以确切的检测候选者解决竞争条件的经验，or writing code which is free of data race or any other race condition。关于这方面最好的书是《Concurrency practices in Java》。
10) 你将如何使用thread dump？你将如何分析Thread dump？
在UNIX中你可以使用kill -3，然后thread dump将会打印日志，在windows中你可以使用”CTRL+Break”。非常简单和专业的线程面试问题，但是如果他问你怎样分析它，就会很棘手。
11) 为什么我们调用start()方法时会执行run()方法，为什么我们不能直接调用run()方法？
这是另一个非常经典的java多线程面试问题。这也是我刚开始写线程程序时候的困惑。现在这个问题通常在电话面试或者是在初中级Java面试的第一轮被问到。这个问题的回答应该是这样的，当你调用start()方法时你将创建新的线程，并且执行在run()方法里的代码。但是如果你直接调用run()方法，它不会创建新的线程也不会执行调用线程的代码。阅读我之前写的《start与run方法的区别》这篇文章来获得更多信息。
12) Java中你怎样唤醒一个阻塞的线程？
这是个关于线程和阻塞的棘手的问题，它有很多解决方法。如果线程遇到了IO阻塞，我并且不认为有一种方法可以中止线程。如果线程因为调用wait()、sleep()、或者join()方法而导致的阻塞，你可以中断线程，并且通过抛出InterruptedException来唤醒它。我之前写的《How to deal with blocking methods in java》有很多关于处理线程阻塞的信息。
13)在Java中CycliBarriar和CountdownLatch有什么区别？
这个线程问题主要用来检测你是否熟悉JDK5中的并发包。这两个的区别是CyclicBarrier可以重复使用已经通过的障碍，而CountdownLatch不能重复使用。
14) 什么是不可变对象，它对写并发应用有什么帮助？
另一个多线程经典面试问题，并不直接跟线程有关，但间接帮助很多。这个java面试问题可以变的非常棘手，如果他要求你写一个不可变对象，
或者问你为什么String是不可变的
————————————-
为什么String要设计成不可变的?
原文链接: Why string is immutable in Java ?
这是一个老生常谈的话题(This is an old yet still popular question). 在Java中将String设计成不可变的是综合考虑到各种因素的结果,想要理解这个问题,需要综合内存,同步,数据结构以及安全等方面的考虑. 在下文中,我将为各种原因做一个小结。
1. 字符串常量池的需要
字符串常量池(String pool, String intern pool, String保留池) 是Java堆内存中一个特殊的存储区域, 当创建一个String对象时,假如此字符串值已经存在于常量池中,则不会创建一个新的对象,而是引用已经存在的对象。
如下面的代码所示,将会在堆内存中只创建一个实际String对象.
- String s1 = “abcd”;
- String s2 = “abcd”;
示意图如下所示:
假若字符串对象允许改变,那么将会导致各种逻辑错误,比如改变一个对象会影响到另一个独立对象. 严格来说，这种常量池的思想,是一种优化手段.
请思考: 假若代码如下所示，s1和s2还会指向同一个实际的String对象吗?
- String s1= “ab” + “cd”;
- String s2= “abc” + “d”;
也许这个问题违反新手的直觉, 但是考虑到现代编译器会进行常规的优化, 所以他们都会指向常量池中的同一个对象. 或者,你可以用 jd-gui 之类的工具查看一下编译后的class文件.
2. 允许String对象缓存HashCode
Java中String对象的哈希码被频繁地使用, 比如在hashMap 等容器中。
字符串不变性保证了hash码的唯一性,因此可以放心地进行缓存.这也是一种性能优化手段,意味着不必每次都去计算新的哈希码. 在String类的定义中有如下代码:
- private int hash;//用来缓存HashCode
3. 安全性
String被许多的Java类(库)用来当做参数,例如 网络连接地址URL,文件路径path,还有反射机制所需要的String参数等, 假若String不是固定不变的,将会引起各种安全隐患。
假如有如下的代码:
- boolean connect(string s){
- if (!isSecure(s)) {
- throw new SecurityException();
- }
- // 如果在其他地方可以修改String,那么此处就会引起各种预料不到的问题/错误
- causeProblem(s);
- }
总体来说, String不可变的原因包括 设计考虑,效率优化问题,以及安全性这三大方面. 事实上,这也是Java面试中的许多 “为什么” 的答案。
相关文章 :
- String对象不可改变的特性
- String is passed by “reference” in Java
- 十大常见Java String问题
- Java中Set的contains()方法
——————————————————————————————
15) 你在多线程环境中遇到的常见的问题是什么？你是怎么解决它的？
多线程和并发程序中常遇到的有Memory-interface、竞争条件、死锁、活锁和饥饿。问题是没有止境的，如果你弄错了，将很难发现和调试。这是大多数基于面试的，而不是基于实际应用的Java线程问题。
补充的其它几个问题：
1) 在java中绿色线程和本地线程区别？
2) 线程与进程的区别？
3) 什么是多线程中的上下文切换？
4)死锁与活锁的区别，死锁与饥饿的区别？
5) Java中用到的线程调度算法是什么？
6) 在Java中什么是线程调度？
7) 在线程中你怎么处理不可捕捉异常？
8) 什么是线程组，为什么在Java中不推荐使用？
9) 为什么使用Executor框架比使用应用创建和管理线程好？
10) 在Java中Executor和Executors的区别？
11) 如何在Windows和Linux上查找哪个线程使用的CPU时间最长？
///
很多核心Java面试题来源于多线程(Multi-Threading)和集合框架(Collections Framework)，理解核心线程概念时，娴熟的实际经验是必需的。这篇文章收集了Java线程方面一些典型的问题，这些问题经常被高级工程师所问到。
0、Java中多线程同步是什么？
在多线程程序下，同步能控制对共享资源的访问。如果没有同步，当一个Java线程在修改一个共享变量时，另外一个线程正在使用或者更新同一个变量，这样容易导致程序出现错误的结果。
1、解释实现多线程的几种方法?
一Java线程可以实现Runnable接口或者继承Thread类来实现，当你打算多重继承时，优先选择实现Runnable。
2、Thread.start()与Thread.run()有什么区别？
Thread.start()方法(native)启动线程，使之进入就绪状态，当cpu分配时间该线程时，由JVM调度执行run()方法。
3、为什么需要run()和start()方法，我们可以只用run()方法来完成任务吗？
我们需要run()&start()这两个方法是因为JVM创建一个单独的线程不同于普通方法的调用，所以这项工作由线程的start方法来完成，start由本地方法实现，需要显示地被调用，使用这俩个方法的另外一个好处是任何一个对象都可以作为线程运行，只要实现了Runnable接口，这就避免因继承了Thread类而造成的Java的多继承问题。
4、什么是ThreadLocal类，怎么使用它？
ThreadLocal是一个线程级别的局部变量，并非“本地线程”。ThreadLocal为每个使用该变量的线程提供了一个独立的变量副本，每个线程修改副本时不影响其它线程对象的副本(译者注)。
下面是线程局部变量(ThreadLocal variables)的关键点：
一个线程局部变量(ThreadLocal variables)为每个线程方便地提供了一个单独的变量。
ThreadLocal实例通常作为静态的私有的(private static)字段出现在一个类中，这个类用来关联一个线程。
当多个线程访问ThreadLocal实例时，每个线程维护ThreadLocal提供的独立的变量副本。
常用的使用可在DAO模式中见到，当DAO类作为一个单例类时，数据库链接(connection)被每一个线程独立的维护，互不影响。(基于线程的单例)
ThreadLocal难于理解，下面这些引用连接有助于你更好的理解它。
《Good article on ThreadLocal on IBM DeveloperWorks 》、《理解ThreadLocal》、《Managing data : Good example》、《Refer Java API Docs》
5、什么时候抛出InvalidMonitorStateException异常，为什么？
调用wait()/notify()/notifyAll()中的任何一个方法时，如果当前线程没有获得该对象的锁，那么就会抛出IllegalMonitorStateException的异常(也就是说程序在没有执行对象的任何同步块或者同步方法时，仍然尝试调用wait()/notify()/notifyAll()时)。由于该异常是RuntimeExcpetion的子类，所以该异常不一定要捕获(尽管你可以捕获只要你愿意).作为RuntimeException，此类异常不会在wait(),notify(),notifyAll()的方法签名提及。
6、Sleep()、suspend()和wait()之间有什么区别？
Thread.sleep()使当前线程在指定的时间处于“非运行”（Not Runnable）状态。线程一直持有对象的监视器。比如一个线程当前在一个同步块或同步方法中，其它线程不能进入该块或方法中。如果另一线程调用了interrupt()方法，它将唤醒那个“睡眠的”线程。
注意：sleep()是一个静态方法。这意味着只对当前线程有效，一个常见的错误是调用t.sleep()，（这里的t是一个不同于当前线程的线程）。即便是执行t.sleep()，也是当前线程进入睡眠，而不是t线程。t.suspend()是过时的方法，使用suspend()导致线程进入停滞状态，该线程会一直持有对象的监视器，suspend()容易引起死锁问题。
object.wait()使当前线程出于“不可运行”状态，和sleep()不同的是wait是object的方法而不是thread。调用object.wait()时，线程先要获取这个对象的对象锁，当前线程必须在锁对象保持同步，把当前线程添加到等待队列中，随后另一线程可以同步同一个对象锁来调用object.notify()，这样将唤醒原来等待中的线程，然后释放该锁。基本上wait()/notify()与sleep()/interrupt()类似，只是前者需要获取对象锁。
=============———————————————–
wait
Wait是Object类的方法，范围是使该Object实例所处的线程。
Sleep()是Thread类专属的静态方法，针对一个特定的线程。
Wait方法使实体所处线程暂停执行，从而使对象进入等待状态，直到被notify方法通知或者wait的等待的时间到。Sleep方法使持有的线程暂停运行，从而使线程进入休眠状态，直到用interrupt方法来打断他的休眠或者sleep的休眠的时间到。Wait方法进入等待状态时会释放同步锁(如上例中的lock对象)，而Sleep方法不会释放同步锁。所以，当一个线程无限Sleep时又没有任何人去interrupt它的时候，程序就产生大麻烦了notify是用来通知线程，但在notify之前线程是需要获得lock的。另个意思就是必须写在synchronized(lockobj) {…}之中。wait也是这个样子，一个线程需要释放某个lock，也是在其获得lock情况下才能够释放，所以wait也需要放在synchronized(lockobj) {…}之中。
Sleep与interrupt
interrupt是个很暴力的方法，打断一个线程的Sleep时并不需要获得该线程的lock。虽然暴力却也有暴力的用处。在一个线程无时限sleep的时候也只有interrupt能够唤醒他。在interrupt的时候会抛出InterruptedException，这个Exception是由Thread 类自动抛出的。因此Interrupt带有强烈的阻塞味道。
wait与interrupt
interrupt同样可以打断wait的等待，与打断sleep不同的是，被打断的wait的线程在重新获得lock之前是不会抛出InterruptedException。
resume和suspend已经被Java遗弃，因为他们天生会引起线程的死锁。
suspend是个贪婪的家伙，当一个线程在suspend的时候，线程会停下来，但却仍然持有在这之前获得的锁定。其他线程无法使用他锁定的任何资源，除非这个挂起的线程被resume之后，他才会继续运行。对于线程的同步，使用wait与notify要安全的多。
————————————–
sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。
在调用sleep()方法的过程中，线程不会释放对象锁。
而当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备
获取对象锁进入运行状态。
=============———————————————–
7、在静态方法上使用同步时会发生什么事？
同步静态方法时会获取该类的“Class”对象，所以当一个线程进入同步的静态方法中时，线程监视器获取类本身的对象锁，其它线程不能进入这个类的任何静态同步方法。它不像实例方法，因为多个线程可以同时访问不同实例同步实例方法。
8、当一个同步方法已经执行，线程能够调用对象上的非同步实例方法吗？
可以，一个非同步方法总是可以被调用而不会有任何问题。实际上，Java没有为非同步方法做任何检查，锁对象仅仅在同步方法或者同步代码块中检查。如果一个方法没有声明为同步，即使你在使用共享数据Java照样会调用，而不会做检查是否安全，所以在这种情况下要特别小心。一个方法是否声明为同步取决于临界区访问(critial section access),如果方法不访问临界区(共享资源或者数据结构)就没必要声明为同步的。
下面有一个示例说明：Common类有两个方法synchronizedMethod1()和method1()，MyThread类在独立的线程中调用这两个方法。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
publicclassCommon {
publicsynchronizedvoidsynchronizedMethod1() {
System.out.println("synchronizedMethod1 called");
try{
Thread.sleep(1000);
}catch(InterruptedException e) {
e.printStackTrace();
}
System.out.println("synchronizedMethod1 done");
}
publicvoidmethod1() {
System.out.println("Method 1 called");
try{
Thread.sleep(1000);
}catch(InterruptedException e) {
e.printStackTrace();
}
System.out.println("Method 1 done");
}
}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
publicclassMyThreadextendsThread {
privateintid = 0;
privateCommon common;
publicMyThread(String name, intno, Common object) {
super(name);
common = object;
id = no;
}
publicvoidrun() {
System.out.println("Running Thread" + this.getName());
try{
if(id == 0) {
common.synchronizedMethod1();
}else{
common.method1();
}
}catch(Exception e) {
e.printStackTrace();
}
}
publicstaticvoidmain(String[] args) {
Common c = newCommon();
MyThread t1 = newMyThread("MyThread-1",0, c);
MyThread t2 = newMyThread("MyThread-2",1, c);
t1.start();
t2.start();
}
}
|
|
1
|
|
这里是程序的输出：
|
1
2
3
4
5
6
|
Running ThreadMyThread-1
synchronizedMethod1 called
Running ThreadMyThread-2
Method1called
synchronizedMethod1 done
Method1done
|
结果表明即使synchronizedMethod1()方法执行了，method1()也会被调用。
9、 在一个对象上两个线程可以调用两个不同的同步实例方法吗？
不能，因为一个对象已经同步了实例方法，线程获取了对象的对象锁。所以只有执行完该方法释放对象锁后才能执行其它同步方法。看下面代码示例非常清晰：Common 类 有synchronizedMethod1()和synchronizedMethod2()方法，MyThread调用这两个方法。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
publicclassCommon {
publicsynchronizedvoidsynchronizedMethod1() {
System.out.println("synchronizedMethod1 called");
try{
Thread.sleep(1000);
}catch(InterruptedException e) {
e.printStackTrace();
}
System.out.println("synchronizedMethod1 done");
}
publicsynchronizedvoidsynchronizedMethod2() {
System.out.println("synchronizedMethod2 called");
try{
Thread.sleep(1000);
}catch(InterruptedException e) {
e.printStackTrace();
}
System.out.println("synchronizedMethod2 done");
}
}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
publicclassMyThreadextendsThread {
privateintid = 0;
privateCommon common;
publicMyThread(String name, intno, Common object) {
super(name);
common = object;
id = no;
}
publicvoidrun() {
System.out.println("Running Thread" + this.getName());
try{
if(id == 0) {
common.synchronizedMethod1();
}else{
common.synchronizedMethod2();
}
}catch(Exception e) {
e.printStackTrace();
}
}
publicstaticvoidmain(String[] args) {
Common c = newCommon();
MyThread t1 = newMyThread("MyThread-1",0, c);
MyThread t2 = newMyThread("MyThread-2",1, c);
t1.start();
t2.start();
}
}
|
10、 什么是死锁
死锁就是两个或两个以上的线程被无限的阻塞，线程之间相互等待所需资源。这种情况可能发生在当两个线程尝试获取其它资源的锁，而每个线程又陷入无限等待其它资源锁的释放，除非一个用户进程被终止。就JavaAPI而言，线程死锁可能发生在一下情况。
●当两个线程相互调用Thread.join()
●当两个线程使用嵌套的同步块，一个线程占用了另外一个线程必需的锁，互相等待时被阻塞就有可能出现死锁。
11、什么是线程饿死，什么是活锁？
线程饿死和活锁虽然不想是死锁一样的常见问题，但是对于并发编程的设计者来说就像一次邂逅一样。
当所有线程阻塞，或者由于需要的资源无效而不能处理，不存在非阻塞线程使资源可用。JavaAPI中线程活锁可能发生在以下情形：
●当所有线程在程序中执行Object.wait(0)，参数为0的wait方法。程序将发生活锁直到在相应的对象上有线程调用Object.notify()或者Object.notifyAll()。
●当所有线程卡在无限循环中。
这里的问题并不详尽，我相信还有很多重要的问题并未提及，您认为还有哪些问题应该包括在上面呢？欢迎在评论中分享任何形式的问题与建议
发布者：全栈程序员-站长，转载请注明出处：https://javaforall.net/173821.html原文链接：https://javaforall.net
