15、Java并发面试题

Java中如何停止一个线程

Jdk1.0有stop()、suspend()、resume()的控制方法，但由于潜在的死锁威胁因此在后序的JDK中被弃用。之后的Java API没有提供兼容其线程安全的停止线程的方法。

当run()或者call()方法执行完的时候线程会自动结束。

如果想手动结束线程，可利用volatile布尔变量来退出run()方法的循环或者取消任务来中断线程。

一个线程运行时发生异常会怎样？

如果异常未被捕获，该线程将会停止执行。Thread.uncaughtExceptionHandler是用于处理未捕获异常造成线程突然中断情况的一个内嵌接口。当一个未捕获异常将造成线程中断的时候JVM会使用Thread.getUncaughtExceptionHandler()来查询线程的UnCaughtExceptionHandler并将线程和异常作为参数传递给handler的uncaughtException()方法进行处理。

线程间如何共享数据，如何协作通信？

通过共享对象，或者使用像阻塞队列类似的并发的数据结构。用wait和notify、notifyAll来实现生产者消费者模型。

Java 中notify和notifyAll的区别

Notify()方法是在同步方法或同步块中调用，即在调用前，线程必须获取该对象的锁，如果调用notify方法时没有持有相应的锁，则会抛出IllegalMonitorStateException。该方法是来通知那些等待该对象的对象锁的其他线程。

当有多个线程等待时，线程规划器任意挑一个wait()状态的线程发出通知，并使它等待获取该对象的对象锁。（notify后，不会立即获取对象锁，因为当前线程要先退出synchronized代码块后，当前线程才会释放锁）

当wait()状态的线程获取到对象锁，且执行完毕后会释放对象锁，此时对象空闲，但其他wait()状态等待的线程必须等待对象发出notify()或notifyAll。(等待的是notify或notifyAll，而不是对象锁)

 

notifyAll

notifyAll()会全部唤醒在该对象上wait的线程，使它们全部退出阻塞状态，无需等待notify或notifyAll，而是等待获取对象锁。当调用notifyAll的线程退出synchronized代码块，释放掉对象锁时，它们就会去竞争。其中一个线程会获取到对象锁，当它执行完释放掉锁后，其他线程继续竞争获取对象锁。

为什么wait、notify、notifyAll方法不在Thread类里面？

wait、notify、notifyAll方法是属于Object类的。Thread是Object的子类。

（1）JAVA提供的锁是对象级的而不是线程级的，每个对象都有锁，通过线程获得。

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

（3）如果线程需要等待某些锁那么调用对象中的wait()方法就有意义了。如果wait()方法定义在Thread类中，线程正在等待的是哪个锁就不明显了。

Java中interrupted和isInterrupted方法的区别

概况：interrupted() 和isInterrupted()的主要区别是前者会将中断状态清除而后者不会。

（1）Java多线程的中断机制是用内部标识来实现的，调用Thread.interrupt()来中断一个线程就会设置中断标识为true。当中断线程调用静态方法Thread.interrupted()来检查中断状态时，中断状态会被清零。

（2）非静态方法isInterrupted()用来查询其它线程的中断状态且不会改变中断状态标识。

简单的说：任何抛出InterruptedException异常的方法都会将中断状态清零。无论如何，一个线程的中断状态有可能被其它线程调用中断来改变。

为什么wait、notify和notifyAll要在同步块中执行？

（1）如果调用某个对象的wait()、notify和notifyAll方法，当前线程必须拥有这个对象的monitor（即锁），因此调用wait()、notify和notifyAll方法必须在同步块或者同步方法中进行（synchronized块或者synchronized方法）。

（2）Java API规范规定，如果不在同步块中执行会抛出IllegalMonitorStateException异常

（3）为了避免wait和notify之间产生竞态条件。（竞态条件会导致程序在并发情况下出现一些bugs。多线程对一些资源的竞争的时候就会产生竞态条件，如果首先要执行的程序竞争失败排到后面执行了，那么整个程序就会出现一些不确定的bugs。这种bugs很难发现而且会重复出现，因为线程间的随机竞争。）

Java多线程中调用wait()和 sleep()方法有什么不同？

Java程序中wait和 sleep都会造成某种形式的暂停，它们可以满足不同的需要。wait()方法用于线程间通信，如果等待条件为真且其它线程被唤醒时，它会释放锁，而sleep()方法仅仅释放CPU资源或者让当前线程停止执行一段时间，但不会释放锁。

 

sleep()强制当前线程休眠，但不会释放锁，如果有synchronized同步块，其他线程仍不能访问共享数据。

在run()方法中调用Thread.sleep().的作用：

（1）线程休眠是帮助其他线程获得运行机会的最好办法

（2）线程睡眠到期自动苏醒到就绪状态而不是运行状态

（3）Sleep方法是静态方法，只能控制当前正在运行的线程。

为什么你应该在循环中检查等待条件?

处于等待状态的线程可能会收到错误警报和伪唤醒，如果不在循环中检查等待条件，程序就会在没有满足结束条件的情况下退出。因此，当一个等待线程醒来时，不能认为它原来的等待状态仍然是有效的，在notify()方法调用之后和等待线程醒来之前这段时间它可能会改变。这就是在循环中使用wait()方法效果更好的原因。

（在使用等待或通知机制时，要配合boolean值或能够判断真假的条件，在notify之前改变boolean量的值，让wait返回后能退出while循环，一般在wait()方法的外围加一层while循环，以防止早期通知或在通知遗漏后阻塞在wait方法内）

代码案例参考：http://blog.csdn.net/ns_code/article/details/17229601

Java中的同步集合与并发集合有什么区别？

同步集合与并发集合都为多线程和并发提供了合适的线程安全的集合，不过并发集合的可扩展性更高。在Java1.5之前程序员们只有同步集合来用且在多线程并发的时候会导致争用，阻碍了系统的扩展性。Java5介绍了并发集合像ConcurrentHashMap，不仅提供线程安全还用锁分离和内部分区等现代技术提高了可扩展性。

Java中堆和栈有什么不同？

为什么把这个问题归类在多线程和并发面试题里？因为栈是一块和线程紧密相关的内存区域。每个线程都有自己的栈内存，用于存储本地变量，方法参数和栈调用，一个线程中存储的变量对其它线程是不可见的。而堆是所有线程共享的一片公用内存区域。对象都在堆里创建，为了提升效率线程会从堆中弄一个缓存到自己的栈，如果多个线程使用该变量就可能引发问题，这时volatile变量就可以发挥作用了，它要求线程从主存中读取变量的值。

什么是线程池？ 为什么要使用它？

创建线程要花费昂贵的资源和时间，如果任务来了才创建线程那么响应时间会变长，而且一个进程能创建的线程数有限。为了避免这些问题，在程序启动的时候就创建若干线程来响应处理，它们被称为线程池，里面的线程叫工作线程。从JDK1.5开始，Java API提供了Executor框架让你可以创建不同的线程池。比如单线程池，每次处理一个任务；数目固定的线程池或者是缓存线程池（一个适合很多生存期短的任务的程序的可扩展线程池）。

如何避免死锁？

死锁现象：当两个或两个以上进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们将一直阻塞下去。

例如：线程A当前持有互斥所锁lock1，线程B当前持有互斥锁lock2。接下来，当线程A仍然持有lock1时，它试图获取lock2，因为线程B正持有lock2，因此线程A会阻塞等待线程B对lock2的释放。如果此时线程B在持有lock2的时候，也在试图获取lock1，因为线程A正持有lock1，因此线程B会阻塞等待A对lock1的释放。二者都在等待对方所持有锁的释放，而二者却又都没释放自己所持有的锁，这时二者便会一直阻塞下去。这种情形称为死锁。

导致死锁的条件：

（1）互斥条件：一个资源每次只能被一个进程使用。

（2）请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。

（3）不剥夺条件：进程已获得的资源，在末使用完之前，不能强行剥夺。

（4）循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

避免死锁的办法：

（1）阻止循环等待条件，将系统中所有的资源设置标志位、排序，规定所有的进程申请资源必须以一定的顺序（升序或降序）做操作来避免死锁。

（2）只在必要的最短时间内持有锁，考虑使用同步语句块代替整个同步方法；

（3）尽量编写不在同一时刻需要持有多个锁的代码，如果不可避免，则确保线程持有第二个锁的时间尽量短

（4）创建和使用一个大锁来代替若干小锁，并把这个锁用于互斥，而不是用作单个对象的对象级别锁。

 Java中活锁和死锁有什么区别？

这是上题的扩展，活锁和死锁类似，不同之处在于处于活锁的线程或进程的状态是不断改变的，活锁可以认为是一种特殊的饥饿。一个现实的活锁例子是两个人在狭小的走廊碰到，两个人都试着避让对方好让彼此通过，但是因为避让的方向都一样导致最后谁都不能通过走廊。简单的说就是，活锁和死锁的主要区别是前者进程的状态可以改变但是却不能继续执行。

怎么检测一个线程是否拥有锁？

在java.lang.Thread中有一个方法叫holdsLock()，它返回true如果当且仅当当前线程拥有某个具体对象的锁。

JVM中哪个参数是用来控制线程的栈堆栈小的

-Xss参数用来控制线程的堆栈大小。JVM配置列表需要了解一下

Java中synchronized和 ReentrantLock有什么不同？

Java在过去很长一段时间只能通过synchronized关键字来实现互斥，它有一些缺点。比如你不能扩展锁之外的方法或者块边界，尝试获取锁时不能中途取消等。Java 5通过Lock接口提供了更复杂的控制来解决这些问题。ReentrantLock 类实现了Lock，它拥有与synchronized 相同的并发性和内存语义且它还具有可扩展性。

有三个线程T1，T2，T3，怎么确保它们按顺序执行？

在多线程中有多种方法让线程按特定顺序执行

用线程类的join()方法在一个线程中启动另一个线程，另外一个线程完成该线程继续执行。为了确保三个线程的顺序你应该先启动最后一个(T3调用T2，T2调用T1)，这样T1就会先完成而T3最后完成。

Thread类中yield()方法的作用？

yield()方法：是静态方法，暂停正在执行的线程对象，交出CPU，让其他具有相同优先级的线程执行。它不会释放对象锁，且yield无法控制交出CPU权限的具体时间，只能让相同优先级的线程有获取运行的权利

作用：让相同优先级的线程之间能轮换执行，大多数yield()调用会使线程从运行状态到就绪状态。

Java中ConcurrentHashMap的并发度是什么？

ConcurrentHashMap把实际map划分成若干部分来实现它的可扩展性和线程安全。这种划分是使用并发度获得的，它是ConcurrentHashMap类构造函数的一个可选参数，默认值为16，这样在多线程情况下就能避免争用。

Java中Semaphore（信号量）是什么？

Java中的Semaphore是一种新的同步类，它是一个计数信号。从概念上讲，信号量维护了一个许可集合。如有必要，在许可可用前会阻塞每一个acquire()，然后再获取该许可。每个release()添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore只对可用许可的号码进行计数，并采取相应的行动。信号量常常用于多线程的代码中，比如数据库连接池。

如果你提交任务时，线程池队列已满。会时发会生什么？

这个问题问得很狡猾，许多程序员会认为该任务会阻塞直到线程池队列有空位。事实上如果一个任务不能被调度执行那么ThreadPoolExecutor’s submit()方法将会抛出一个RejectedExecutionException异常。

 

Java线程池中submit()和 execute()方法有什么区别？

两个方法都可以向线程池提交任务，execute()方法的返回类型是void，它定义在Executor接口中,而submit()方法可以返回持有计算结果的Future对象，它定义在ExecutorService接口中，它扩展了Executor接口，其它线程池类像ThreadPoolExecutor和ScheduledThreadPoolExecutor都有这些方法。

什么是阻塞式方法？

阻塞式方法是指程序会一直等待该方法完成期间不做其他事情，ServerSocket的accept()方法就是一直等待客户端连接。这里的阻塞是指调用结果返回之前，当前线程会被挂起，直到得到结果之后才会返回。此外，还有异步和非阻塞式方法在任务完成前就返回。

Swing是线程安全的吗？ 为什么？

Swing不是线程安全的，当我们说swing不是线程安全的常常提到它的组件，这些组件不能在多线程中进行修改，所有对GUI组件的更新都要在AWT线程中完成，而Swing提供了同步和异步两种回调方法来进行更新。

Java中的ReadWriteLock是什么？

一般而言，读写锁是用来提升并发程序性能的锁分离技术的成果。Java中的ReadWriteLock是Java 5 中新增的一个接口，一个ReadWriteLock维护一对关联的锁，一个用于只读操作一个用于写。在没有写线程的情况下一个读锁可能会同时被多个读线程持有。写锁是独占的，你可以使用JDK中的ReentrantReadWriteLock来实现这个规则，它最多支持65535个写锁和65535个读锁。

多线程中的忙循环是什么?

忙循环就是程序员用循环让一个线程等待，不像传统方法wait(), sleep() 或 yield() 它们都放弃了CPU控制，而忙循环不会放弃CPU，它就是在运行一个空循环。这么做的目的是为了保留CPU缓存，在多核系统中，一个等待线程醒来的时候可能会在另一个内核运行，这样会重建缓存。为了避免重建缓存和减少等待重建的时间就可以使用它了。

volatile 变量和 atomic 变量有什么不同？

这是个有趣的问题。首先，volatile 变量和atomic 变量看起来很像，但功能却不一样。Volatile变量可以确保先行关系，即写操作会发生在后续的读操作之前,但它并不能保证原子性。例如用volatile修饰count变量那么count++ 操作就不是原子性的。而AtomicInteger类提供的atomic方法可以让这种操作具有原子性如getAndIncrement()方法会原子性的进行增量操作把当前值加一，其它数据类型和引用变量也可以进行相似操作。

单例模式的双检锁是什么？

http://blog.csdn.net/ns_code/article/details/17348313

如何在Java中创建线程安全的Singleton？

http://blog.csdn.net/ns_code/article/details/17359719

单例模式

只有一个实例

必须自己创建自己的一个实例

必须给所有其他对象提供这一实例

（1）饿汉式单例模式（常用）

（2）懒汉式单例模式-延迟加载（适用于单线程环境下）

（3）DCL单例模式：double-check locking

（4）static内部类单例模式（常用）

class Single   

{  

    private Single()(  

        Syustem.out.println("ok");  

    )  

      

    private static class InstanceHolder{  

        private static final Singlet instance = new Single();  

    }  

  

    public static Single getInstance(){  

        return InstanceHolder.instance;  

    }  

}  

写出3条你遵循的多线程最佳实践

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。