1. 多线程使用的优缺点？

优点：

（1）多线程技术使程序的响应速度更快

（2）当前没有进行处理的任务可以将处理器时间让给其它任务

（3）占用大量处理时间的任务可以定期将处理器时间让给其它任务

（4）可以随时停止任务

（5）可以分别设置各个任务的优先级以及优化性能

缺点：

（1）等候使用共享资源时造成程序的运行速度变慢

（2）对线程进行管理要求额外的cpu开销

（3）可能出现线程死锁情况。即较长时间的等待或资源竞争以及死锁等症状

2. start（）方法和run（）方法简介和区别？

start（）方法：

1）用start方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。

2）通过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到CPU时间片，就开始执行run()方法。

run（）方法：

1）run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条。

总结：

1）调用start方法方可启动线程，

2）而run方法只是thread的一个普通方法调用，还是在主线程里执行。

3）把需要并行处理的代码放在run()方法中，start()方法启动线程将自动调用run()方法，这是由jvm的内存机制规定的。

4）并且run()方法必须是public访问权限，返回值类型为void

3. Runnable接口和Callable接口的相同点和不同点?

4. volatile关键字的作用是什么？

（1）多线程使用volatile关键字修饰的变量，保证了其在多线程之间的可见性，即每次读取到volatile变量，一定是最新的数据

（2）Java代码执行中，为了获取更好的性能JVM可能会对指令进行重排序，多线程下可能会出现一些意想不到的问题。使用volatile则会对禁止语义重排序，当然这也一定程度上降低了代码执行效率

5. CyclicBarrier和CountDownLatch的区别是什么？

6. volatile和synchronized对比？

1）volatile本质是在告诉jvm当前变量在寄存器中的值是不确定的,需要从主存中读取,synchronized则是锁定当前变量,只有当前线程可以访问该变量,其他线程被阻塞住.

2）volatile仅能使用在变量级别,synchronized则可以使用在变量,方法.

3）volatile仅能实现变量的修改可见性,而synchronized则可以保证变量的修改可见性和原子性.　　

4）volatile不会造成线程的阻塞,而synchronized可能会造成线程的阻塞

7. 怎么唤醒一个阻塞的线程？

如果线程是因为调用了wait()、sleep()或者join()方法而导致的阻塞，可以中断线程，并且通过抛出InterruptedException来唤醒它；如果线程遇到了IO阻塞，无能为力，因为IO是操作系统实现的，Java代码并没有办法直接接触到操作系统

8. Java中如何获取到线程dump文件？

dump文件的作用：

死循环、死锁、阻塞、页面打开慢等问题，打线程dump是最好的解决问题的途径。因此，线程dump也就是线程堆栈。

获取到线程堆栈dump文件内容分两步：

（1）第一步：获取到线程的pid，Linux环境下可以使用ps -ef | grep java

（2）第二步：打印线程堆栈，可以通过使用jstack pid命令

9. sleep方法和wait方法的相同点和不同点？

相同点：

二者都可以让线程处于冻结状态。

不同点：

1）首先应该明确sleep方法是Thread类中定义的方法，而wait方法是Object类中定义的方法。

2）sleep方法必须人为地为其指定时间。

wait方法既可以指定时间，也可以不指定时间。

3）sleep方法时间到，线程处于临时阻塞状态或者运行状态。

wait方法如果没有被设置时间，就必须要通过notify或者notifyAll来唤醒。

4）sleep方法不一定非要定义在同步中。

wait方法必须定义在同步中。

5）当二者都定义在同步中时，

线程执行到sleep，不会释放锁。

线程执行到wait，会释放锁

10. 生产者和消费者模型的作用是什么？

1）通过平衡生产者的生产能力和消费者的消费能力来提升整个系统的运行效率，这是生产者消费者模型最重要的作用

2）解耦，这是生产者消费者模型附带的作用，解耦意味着生产者和消费者之间的联系少，联系越少越可以独自发展而不需要收到相互的制约

11. ThreadLocal的作用是什么？

1）ThreadLocal用来解决多线程程序的并发问题

2）ThreadLocal并不是一个Thread,而是Thread的局部变量,当使用ThreadLocal维护变量时,ThreadLocal为每个使用该变量的线程提供独立的变量副本,所以每个线程都可以独立地改变自己的副本,而不会影响其它线程所对应的副本.

3）从线程的角度看，目标变量就象是线程的本地变量，这也是类名中“Local”所要表达的意思。

4）线程局部变量并不是Java的新发明,Java没有提供在语言级支持(语法上),而是变相地通过ThreadLocal的类提供支持

12. wait方法和notify/notifyAll方法在放弃对象监视器时有什么区别？

wait()方法立即释放对象监视器；

notify()/notifyAll()方法则会等待线程剩余代码执行完毕才会放弃对象监视器

13. Lock和synchronized对比？

1）Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；

　2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；

　3）Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；

　4）通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。

　5）Lock可以提高多个线程进行读操作的效率。

　6）在JDK1.5中，synchronized是性能低效的。因为这是一个重量级操作，它对性能最大的影响是阻塞式的实现，挂起线程和恢复线程的操作都需要转入内核态中完成，这些操作给系统的并发性带来了很大的压力。相比之下使用Java提供的Lock对象，性能更高一些。

但是，JDK1.6，发生了变化，对synchronize加入了很多优化措施，有自适应自旋，锁消除，锁粗化，轻量级锁，偏向锁等等。导致在JDK1.6上synchronize的性能并不比Lock差。因此。提倡优先考虑使用synchronized来进行同步

14、ConcurrentHashMap的并发度是什么？

ConcurrentHashMap的并发度就是segment的大小，默认为16，这意味着最多同时可以有16条线程操作ConcurrentHashMap，这也是ConcurrentHashMap对Hashtable的最大优势，任何情况下，Hashtable能同时有两条线程获取Hashtable中的数据

15、ReadWriteLock是什么？

ReadWriteLock是一个读写锁接口，ReentrantReadWriteLock是ReadWriteLock接口的一个具体实现，实现了读写的分离，读锁是共享的，写锁是独占的，读和读之间不会互斥，读和写、写和读、写和写之间才会互斥，提升了读写的性能

16、FutureTask是什么？

FutureTask表示一个异步运算的任务。FutureTask里面可以传入一个Callable的具体实现类，可以对这个异步运算的任务的结果进行等待获取、判断是否已经完成、取消任务等操作。由于FutureTask也是Runnable接口的实现类，所以FutureTask也可以放入线程池中

17、Java中用到的线程调度算法是什么？

抢占式。一个线程用完CPU之后，操作系统会根据线程优先级、线程饥饿情况等数据算出一个总的优先级并分配下一个时间片给某个线程执行

18、单例模式的线程安全性？

单例模式的线程安全意味着：某个类的实例在多线程环境下只会被创建一次出来。单例模式有很多种的写法，具体分析如下：

（1）饿汉式单例模式的写法：线程安全

（2）懒汉式单例模式的写法：非线程安全

（3）双检锁单例模式的写法：线程安全

19、什么是乐观锁和悲观锁？

（1）乐观锁：对于并发间操作产生的线程安全问题持乐观状态，乐观锁认为竞争不总是会发生，因此它不需要持有锁，将比较-设置这两个动作作为一个原子操作尝试去修改内存中的变量，如果失败则表示发生冲突，那么就应该有相应的重试逻辑。

（2）悲观锁：对于并发间操作产生的线程安全问题持悲观状态，悲观锁认为竞争总是会发生，因此每次对某资源进行操作时，都会持有一个独占的锁，就像synchronized，直接对操作资源上了锁

20. Java编写一个会导致死锁的程序？

死锁现象描述：

线程A和线程B相互等待对方持有的锁导致程序无限死循环下去。

死锁的实现步骤：

（1）两个线程里面分别持有两个Object对象：lock1和lock2。这两个lock作为同步代码块的锁；

（2）线程1的run()方法中同步代码块先获取lock1的对象锁，Thread.sleep(xxx)，时间不需要太多，100毫秒差不多了，然后接着获取lock2的对象锁。这么做主要是为了防止线程1启动一下子就连续获得了lock1和lock2两个对象的对象锁

（3）线程2的run)(方法中同步代码块先获取lock2的对象锁，接着获取lock1的对象锁，当然这时lock1的对象锁已经被线程1锁持有，线程2肯定是要等待线程1释放lock1的对象锁的

这样，线程1″睡觉”睡完，线程2已经获取了lock2的对象锁了，线程1此时尝试获取lock2的对象锁，便被阻塞，此时一个死锁就形成了

输出结果是：

线程A 锁住资源O1,等待O2

线程B 锁住资源O2,等待O1