**
多线程面试题
**
1. 多线程的创建方式
(1)、继承 Thread 类:但 Thread 本质上也是实现了 Runnable 接口的一个实例,它代表一个线程的实例,并且,启动线程的唯一方法就是通过 Thread 类的 start()实例方法。start()方法是一个 native 方法,它将启动一个新线程,并执行 run()方法。这种方式实现多线程很简单,通过自己的类直接 extend Thread,并复写 run()方法,就可以启动新线程并执行自己定义的 run()方法。例如:继承 Thread 类实现多线程,并在合适的地方启动线程
1.public class MyThread extends Thread {
2. public void run() {
3. System.out.println("MyThread.run()");
4. }
5.}
6.MyThread myThread1 = new MyThread();
7.MyThread myThread2 = new MyThread();
8.myThread1.start();
9.myThread2.start();
(2)、实现 Runnable 接口的方式实现多线程,并且实例化 Thread,传入自己的 Thread 实例,调用 run( )方法
1.public class MyThread implements Runnable {
2. public void run() {
3. System.out.println("MyThread.run()");
4. }
5.} 6.MyThread myThread = new MyThread();
7.Thread thread = new Thread(myThread);
8.thread.start();
(3)、使用 ExecutorService、Callable、Future 实现有返回结果的多线程:ExecutorService、Callable、Future
这 个 对 象 实 际 上 都 是 属 于 Executor 框 架 中 的 功 能 类 。 想 要 详 细 了 解 Executor 框 架 的 可 以 访 问http://www.javaeye.com/topic/366591 ,这里面对该框架做了很详细的解释。返回结果的线程是在 JDK1.5 中引入的新特征,确实很实用,有了这种特征我就不需要再为了得到返回值而大费周折了,而且即便实现了也可能漏洞百出。
可返回值的任务必须实现 Callable 接口,类似的,无返回值的任务必须 Runnable 接口。执行 Callable 任务后,可以获取一个 Future 的对象,在该对象上调用 get 就可以获取到 Callable 任务返回的 Object 了,再结合线程池接口ExecutorService 就可以实现传说中有返回结果的多线程了。下面提供了一个完整的有返回结果的多线程测试例子,在JDK1.5 下验证过没问题可以直接使用。代码如下:
1.import java.util.concurrent.*;
2.import java.util.Date;
3.import java.util.List;
4.import java.util.ArrayList;
5.6./**
7.* 有返回值的线程
8.*/9.@SuppressWarnings("unchecked")
10.public class Test {
11.public static void main(String[] args) throws ExecutionException,
12. InterruptedException {
13. System.out.println("----程序开始运行----");
14. Date date1 = new Date();
15.
16. int taskSize = 5;
17. // 创建一个线程池
18. ExecutorService pool = Executors.newFixedThreadPool(taskSize);
19. // 创建多个有返回值的任务
20. List<Future> list = new ArrayList<Future>();
21. for (int i = 0; i < taskSize; i++) {
22. Callable c = new MyCallable(i + " ");
23. // 执行任务并获取 Future 对象
24. Future f = pool.submit(c);
25. // System.out.println(">>>" + f.get().toString());
26. list.add(f);
27. }
28. // 关闭线程池
29. pool.shutdown();
30.
31. // 获取所有并发任务的运行结果
32. for (Future f : list) {
33. // 从 Future 对象上获取任务的返回值,并输出到控制台
34. System.out.println(">>>" + f.get().toString());
35. }
36.
37. Date date2 = new Date();
38. System.out.println("----程序结束运行----,程序运行时间【"
39. + (date2.getTime() - date1.getTime()) + "毫秒】");
40.}
41.}
42.
43.class MyCallable implements Callable<Object> {
44.private String taskNum;
45.
46.MyCallable(String taskNum) {
47. this.taskNum = taskNum;
48.}
49.
50.public Object call() throws Exception {
51. System.out.println(">>>" + taskNum + "任务启动");
52. Date dateTmp1 = new Date();
53. Thread.sleep(1000);
54. Date dateTmp2 = new Date();
55. long time = dateTmp2.getTime() - dateTmp1.getTime();
56. System.out.println(">>>" + taskNum + "任务终止");
57. return taskNum + "任务返回运行结果,当前任务时间【" + time + "毫秒】";
58.}
59.}
2. 在 java 中 wait 和 sleep 方法的不同?
最大的不同是在等待时 wait 会释放锁,而 sleep 一直持有锁。wait 通常被用于线程间交互,sleep 通常被用于暂
停执行。
3. synchronized 和 volatile 关键字的作用
一旦一个共享变量(类的成员变量、类的静态成员变量)被 volatile 修饰之后,那么就具备了两层语义:
1)保证了不同线程对这个变量进行操作时的可见性,即一个线程修改了某个变量的值,这新值对其他线程来说是
立即可见的。
2)禁止进行指令重排序。
volatile 本质是在告诉 jvm 当前变量在寄存器(工作内存)中的值是不确定的,需要从主存中读取;
synchronized 则是锁定当前变量,只有当前线程可以访问该变量,其他线程被阻塞住。
1.volatile 仅能使用在变量级别;
synchronized 则可以使用在变量、方法、和类级别的
2.volatile 仅能实现变量的修改可见性,并不能保证原子性;
synchronized 则可以保证变量的修改可见性和原子性
3.volatile 不会造成线程的阻塞;
synchronized 可能会造成线程的阻塞。
4.volatile 标记的变量不会被编译器优化;
synchronized 标记的变量可以被编译器优化
4. 分析线程并发访问代码解释原因
1. public class Counter {
2. private volatile int count = 0;
3. public void inc(){
4. try {
5. Thread.sleep(3);
6. } catch (InterruptedException e) {
7. e.printStackTrace();
8. }
9. count++;
10. }
11. @Override
12. public String toString() {
13. return "[count=" + count + "]";
14. }
15. }
16. //---------------------------------华丽的分割线-----------------------------
17. public class VolatileTest {
18. public static void main(String[] args) {
19. final Counter counter = new Counter();
20. for(int i=0;i<1000;i++){
21. new Thread(new Runnable() {
22. @Override
23. public void run() {
24. counter.inc();
25. }
26. }).start();
27. }
28. System.out.println(counter);
29. }
30. }
上面的代码执行完后输出的结果确定为 1000 吗?
答案是不一定,或者不等于 1000。这是为什么吗?
在 java 的内存模型中每一个线程运行时都有一个线程栈,线程栈保存了线程运行时候变量值信息。当线程访问某一个对象时候值的时候,首先通过对象的引用找到对应在堆内存的变量的值,然后把堆内存变量的具体值 load 到线程本地内存中,建立一个变量副本,之后线程就不再和对象在堆内存变量值有任何关系,而是直接修改副本变量的值,在修改完之后的某一个时刻(线程退出之前),自动把线程变量副本的值回写到对象在堆中变量。这样在堆中的对象的值就产生变化了。也就是说上面主函数中开启了 1000 个子线程,每个线程都有一个变量副本,每个线程修改变量只是临时修改了自己的副本,当线程结束时再将修改的值写入在主内存中,这样就出现了线程安全问题。因此结果就不可能等于 1000了,一般都会小于 1000。
上面的解释用一张图表示如下:
5. 什么是线程池,如何使用?
线程池就是事先将多个线程对象放到一个容器中,当使用的时候就不用 new 线程而是直接去池中拿线程即可,节省了开辟子线程的时间,提高的代码执行效率。
在 JDK 的 java.util.concurrent.Executors 中提供了生成多种线程池的静态方法。
-
ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
-
ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(4);
-
ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(4);
-
ExecutorService newSingleThreadExecutor =Executors.newSingleThreadExecutor();
然后调用他们的 execute 方法即可。
6. 常用的线程池有哪些?
newSingleThreadExecutor:创建一个单线程的线程池,此线程池保证所有任务的执行顺序按照任务的提交顺序执行。
newFixedThreadPool:创建固定大小的线程池,每次提交一个任务就创建一个线程,直到线程达到线程池的最大大小。
newCachedThreadPool:创建一个可缓存的线程池,此线程池不会对线程池大小做限制,线程池大小完全依赖于操作系统(或者说 JVM)能够创建的最大线程大小。
newScheduledThreadPool:创建一个大小无限的线程池,此线程池支持定时以及周期性执行任务的需求。
newSingleThreadExecutor:创建一个单线程的线程池。此线程池支持定时以及周期性执行任务的需求。
7. 请叙述一下您对线程池的理解?
(如果问到了这样的问题,可以展开的说一下线程池如何用、线程池的好处、线程池的启动策略)
合理利用线程池能够带来三个好处。
第一:降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
第二:提高响应速度。当任务到达时,任务可以不需要等到线程创建就能立即执行。
第三:提高线程的可管理性。线程是稀缺资源,如果无限制的创建,不仅会消耗系统资源,还会降低系统的稳定性,使用线程池可以进行统一的分配,调优和监控。
8. 线程池的启动策略?
官方对线程池的执行过程描述如下:- /*
-
- Proceed in 3 steps:
-
-
-
- If fewer than corePoolSize threads are running, try to
-
-
- start a new thread with the given command as its first
-
- task. The call to addWorker atomically checks runState and
-
- workerCount, and so prevents false alarms that would add
-
- threads when it shouldn’t, by returning false.
-
-
-
- If a task can be successfully queued, then we still need
-
-
- to double-check whether we should have added a thread
-
- (because existing ones died since last checking) or that
-
- the pool shut down since entry into this method. So we
-
- recheck state and if necessary roll back the enqueuing if
-
- stopped, or start a new thread if there are none.
-
-
-
- If we cannot queue task, then we try to add a new
-
-
- thread. If it fails, we know we are shut down or saturated
-
- and so reject the task.
- */
1、线程池刚创建时,里面没有一个线程。任务队列是作为参数传进来的。不过,就算队列里面有任务,线程池也不会马上执行它们。
2、当调用 execute() 方法添加一个任务时,线程池会做如下判断:
a. 如果正在运行的线程数量小于 corePoolSize,那么马上创建线程运行这个任务;
b. 如果正在运行的线程数量大于或等于 corePoolSize,那么将这个任务放入队列。
c. 如果这时候队列满了,而且正在运行的线程数量小于 maximumPoolSize,那么还是要创建线程运行这个任务;
d. 如果队列满了,而且正在运行的线程数量大于或等于 maximumPoolSize,那么线程池会抛出异常,告诉调用者“我不能再接受任务了”。
3、当一个线程完成任务时,它会从队列中取下一个任务来执行。
4、当一个线程无事可做,超过一定的时间(keepAliveTime)时,线程池会判断,如果当前运行的线程数大于
corePoolSize,那么这个线程就被停掉。所以线程池的所有任务完成后,它最终会收缩到 corePoolSize 的大小。