面试题:Java多线程必须掌握的十个问题 背1

一、进程与线程？并行与并发？

进程代表一个运行中的程序，是资源分配与调度的基本单位。进程有三大特性：

1、独立性：独立的资源，私有的地址空间，进程间互不影响。

2、动态性：进程具有生命周期。

3、并发性：多进程可以在单核CPU上并发运行。

线程代表进程中的一个顺序执行流，多线程就是一个进程中的多个顺序执行流。线程也被称为轻量级的进程，是系统运行的基本单位。

多线程的优势（进程线程区别）：

1、进程之间不能共享内存，线程之间共享内存更容易，多线程可协作完成进程工作；

2、创建进程进行资源分配的代价较创建线程要大得多，所以多线程在高并发环境中效率更高。

---

 

并行与并发：

并行是指：多核多CPU或多机器处理同一段处理逻辑的时候，同一时刻多个执行流共同执行。

并发是指：通过CPU的调度算法，使用户感觉像是同时处理多个任务，但同一时刻只有一个执行流占用CPU执行。即使多核多CPU环境还是会使用并发，以提高处理效率。

主要的CPU调度算法有如下两种：

1、分时调度：每个线程轮流获取CPU使用权，各个线程平均CPU时间片。

2、抢占式调度：Java虚拟机使用的就是这种调度模型。这种调度方式会根据线程优先级，先调度优先级高的线程，如果线程优先级相同，会随机选取线程执行。

---

 

---

 

三、Java创建线程的四种方式？

1、继承Thread类，实现run()方法。

2、实现Runnable接口，实现run()方法。Runnable实例对象作为Thread构造方法中的target参数传入，充当线程执行体。这种方式适用于多个线程共享资源的情况。

3、实现Callable<Class>接口，实现call()方法。

 

call()方法与run()方法的两个主要区别：

1、call()方法可以有返回值，且返回值类型需要与声明接口时的泛型类型一致。

2、call()方法可以抛出异常。

使用这种方式，步骤较前两种方式比较复杂：

1、在声明接口时就需要指定泛型类型，且call()方法的返回值类型要与泛型类型一致。

2、使用FutureTask<Class>封装Callable实例对象，作为Thread构造方法中的target参数传入。

3、在调用start()后，可使用FutureTask的get()方法获取返回值。

4、实现java.util.concurrent.ThreadFactory接口，实现newThread(Runnable r)方法，自定义创建细节。

---

 

四、Java终止线程的四种方式？（可参看博客http://blog.csdn.net/zhangliangzi/article/details/52484302）

1、自然终止，run()方法执行结束后，线程自动终止。

2、使用stop()方法，已经被弃用。

3、使用volatile 标志位（其实就是外部控制的自然死亡）。

4、使用interrupt()方法中断运行态和阻塞态线程。（关于interrupt()，调用interrupt()方法，立刻改变的是中断状态，但如果不是在阻塞态，就不会抛出异常；如果在进入阻塞态后，中断状态为已中断，就会立刻抛出异常。但是在获取synchronized锁的过程中不可被中断。详解可参看：http://blog.csdn.net/zhangliangzi/article/details/52485319）

注意：当线程抛出一个未被捕获的异常或错误时，线程会异常终止。

---

 

五、sleep()方法与wait()方法区别是什么？wait()方法为什么属于Object类？

它们的都是使线程“等待”一段时间，但是：

sleep()方法是Thread类下的方法，控制线程休眠，休眠过程中不会释放锁，sleep()时间到后进入就绪态等待调度。

wait()方法是Object类下的方法，控制线程等待，等待过程会释放锁，被notify()后会进入就绪态等待调度。

 

至于wait()方法为什么属于Object类，而不是Thread类，是因为：

wait()方法用于多个线程争用一把锁（一般为Synchronized锁住的对象）的情况，同一时刻只有一个线程能够获得锁，其他线程就要在线程队列等待。作用对象就是被锁住的对象，所以线程队列的维护工作应该交给Object。如果交给Thread，那么每个Thread都要知道其他Thread的状态，这并不合理。

---

 

六、start()方法与run()方法区别？

start()方法用于启动线程，会把线程状态由新建态转为就绪态，为线程分配线程私有的方法栈、程序计数器等资源，而start()方法会自动把run()方法作为线程执行体。

run()方法本身与普通方法并无二致，直接调用run()方法不会具有线程的意义。

---

 

七、简述线程的生命周期

1、新建态，通过上述几种方式创建了具有线程执行体的Thread对象，就进入了新建态。

2、就绪态，调用Thread对象的start()方法，就会为线程分配线程私有的方法栈、程序计数器资源，如果得到CPU资源，线程就会由就绪态转为运行态。换句话说，就绪态的线程获得了除CPU之外的所有必须资源。

3、运行态，就绪态线程得到CPU资源就会转为运行态，执行run()方法。当然，在调用yield()线程让步的情况，线程会由运行态转到就绪态，但这个过程可能是及其短暂的，如果当前线程拥有较高的优先级，即使让步后，它也会直接转为运行态。

4、阻塞态，会导致阻塞态的方法主要有：sleep()方法、wait()方法、join()方法、等待获取锁、等待IO等情况。在这些情况被处理后，就会转为就绪态，等待调度。

5、终止态，包括第四个问题所说的几种情况。

---

 

八、后台线程是什么？有什么应用？  守护线程

后台线程如其名，就是在后台工作的线程，它的任务是为其他线程提供服务，也叫做“守护线程”与“精灵线程”。通过在start()方法调用前，调用setDeamon(true)方法，将线程设置为后台线程。后台线程会在前台线程死亡后由JVM通知死亡。

后台线程最大的应用就是垃圾回收线程，它是一个典型的后台线程。

---

 

九、Java常见的锁类型有哪些？请简述其特点。

1、synchronized对象同步锁：synchronized是对对象加锁，可作用于对象、方法（相当于对this对象加锁）、静态方法（相当于对Class实例对象加锁，锁住的该类的所有对象）以保证并发环境的线程安全。同一时刻只有一个线程可以获得锁。

其底层实现是通过使用对象监视器Monitor，每个对象都有一个监视器，当线程试图获取Synchronized锁定的对象时，就会去请求对象监视器（Monitor.Enter()方法），如果监视器空闲，则请求成功，会获取执行锁定代码的权利；如果监视器已被其他线程持有，线程进入同步队列等待。

2、Lock同步锁：与synchronized功能类似，可从Lock与synchronized区别进行分析：

1、Lock可以通过tryLock()方法非阻塞地获取锁而。如果获取了锁即立刻返回true，否则立刻返回false。这个方法还有加上定时等待的重载方法tryLock(long time, TimeUnit unit)方法，在定时期间内，如果获取了锁立刻返回true，否则在定时结束后返回false。在定时等待期间可以被中断，抛出InterruptException异常。而Synchronized在获得锁的过程中是不可被中断的。

2、Lock可以通过lockInterrupt()方法可中断的获取锁，与lock()方法不同的是等待时可以响应中断，抛出InterruptException异常。

3、Synchronized是隐式的加锁解锁，而Lock必须显示的加锁解锁，而且解锁应放到finnally中，保证一定会被解锁，而Synchronized在出现异常时也会自动解锁。但也因为这样，Lock更加灵活。

4、Synchronized是JVM层面上的设计，对对象加锁，基于对象监视器。Lock是代码实现的。

3、可重入锁：ReentrantLock与Synchronized都是可重入锁。可重入意味着，获得锁的线程可递归的再次获取锁。当所有锁释放后，其他线程才可以获取锁。

4、公平锁与非公平锁：“公平性”是指是否等待最久的线程就会获得资源。如果获得锁的顺序是顺序的，那么就是公平的。不公平锁一般效率高于公平锁。ReentrantLock可以通过构造函数参数控制锁是否公平。

5、ReentrantReadWriteLock读写锁：是一种非排它锁， 一般的锁都是排他锁，就是同一时刻只有一个线程可以访问，比如Synchronized和Lock。读写锁就多个线程可以同时获取读锁读资源，当有写操作的时候，获取写锁，写操作之后的读写操作都将被阻塞，直到写锁释放。读写锁适合写操作较多的场景，效率较高。

6、乐观锁与悲观锁：在Java中的实际应用类并不多，大多用在数据库锁上，可参看：http://blog.csdn.net/sdyy321/article/details/6183412

7、死锁：是当两个线程互相等待获取对方的对象监视器时就会发生死锁。一旦出现死锁，整个程序既不会出现异常也不会有提示，但所有线程都处于阻塞状态。死锁一般出现于多个同步监视器的情况。

---

 

十、volatile与automicInteger是什么？如何使用？

在并发环境中有三个因素需要慎重考量，原子性、可见性、有序性。

volatile主要用于解决可见性，它修饰变量，相当于对当前语句前后加上了“内存栅栏”。使当前代码之前的代码不会被重排到当前代码之后，当前代码之后的指令不会被重排到当前代码之前，一定程度保证了有序性。而volatile最主要的作用是使修改volatile修饰的变量值时会使所有线程中的缓存失效，并强制写入公共主存，保证了各个线程的一致。可以看做是轻量级的Synchronized。详情可参看：http://www.cnblogs.com/dolphin0520/p/3920373.html。

automicXXX主要用于解决原子性，有一个很经典的问题：i++是原子性的操作码？答案是不是，它其实是两步操作，一步是取i的值，一步是++。在取值之后如果有另外的线程去修改这个值，那么当前线程的i值就是旧数据，会影响最后的运算结果。使用automicXXX就可以非阻塞、保证原子性的对数据进行增减操作。详情可参看：http://ifeve.com/java-atomic/

 

注：在此列举的只是Java多线程最基础的知识，也是面试官最常问到的，先打牢基础，再去探讨底层原理或者高级用法，除了这十个问题，在此再推荐一些其他的资料：

JVM底层又是如何实现synchronized的：http://www.open-open.com/lib/view/open1352431526366.html

Java线程池详解：http://blog.csdn.net/zhangliangzi/article/details/52389766

Java线程池深度解析：http://www.cnblogs.com/dolphin0520/p/3932921.html

ConcurrentHashMap原理分析：http://www.cnblogs.com/ITtangtang/p/3948786.html

Java阻塞队列详解：http://ifeve.com/java-blocking-queue/