java面试题解惑 之 多线程(转)

1，多线程
线程或者说多线程，是我们处理多任务的强大工具。
线程与进程的区别：[/size]
线程和进程是不同的，每个进程都是一个独立运行的程序，拥有自己的变量，且不同进程间的变量不能共享；而线程是运行在进程内部的，每个正在运行的进程至少有一个线程，而且不同的线程之间可以在进程范围内共享数据。也就是说进程有自己独立的存储空间，而线程是和它所属的进程内的其他线程共享一个存储空间。线程的使用可以使我们能够并行地处理一些事情。线程通过并行的处理给用户带来更好的使用体验，比如你使用的邮件系统（outlook、Thunderbird、foxmail等），你当然不希望它们在收取新邮件的时候，导致你连已经收下来的邮件都无法阅读，而只能等待收取邮件操作执行完毕。这正是线程的意义所在。
java中有两中方式实现多线程，一种是继承Thread类，一种实现Runnable接口线程启动是用start方法，而非run方法。
线程状态的具体信息如下：
1. NEW（新建状态、初始化状态）：线程对象已经被创建，但是还没有被启动时的状态。
这段时间就是在我们调用new命令之后，调用start()方法之前。
2. RUNNABLE（可运行状态、就绪状态）：在我们调用了线程的start()方法之后线程所
处的状态。处于RUNNABLE状态的线程在JAVA虚拟机（JVM）上是运行着的，但是它可
能还正在等待操作系统分配给它相应的运行资源以得以运行。
3. BLOCKED（阻塞状态、被中断运行）：线程正在等待其它的线程释放同步锁，以进
入一个同步块或者同步方法继续运行；或者它已经进入了某个同步块或同步方法，在运行的
过程中它调用了某个对象继承自java.lang.Object的wait()方法，正在等待重新返回这个同步块或同步方法。
4. WAITING（等待状态）：当前线程调用了java.lang.Object.wait()、
java.lang.Thread.join()或者java.util.concurrent.locks.LockSupport.park()三个中的任意一个方法，
正在等待另外一个线程执行某个操作。比如一个线程调用了某个对象的wait()方法，正在等
待其它线程调用这个对象的notify() 或者notifyAll()（这两个方法同样是继承自Object类）方
法来唤醒它；或者一个线程调用了另一个线程的join()（这个方法属于 Thread类）方法，正在等待这个方法运行结束。
5. TIMED_WAITING（定时等待状态）：当前线程调用了 java.lang.Object.wait(long
timeout)、java.lang.Thread.join(long
millis)、java.util.concurrent.locks.LockSupport.packNanos(long
nanos)、java.util.concurrent.locks.LockSupport.packUntil(long deadline)四个方法中的任意一个，
进入等待状态，但是与WAITING状态不同的是，它有一个最大等待时间，即使等待的条件
仍然没有满足，只要到了这个时间它就会自动醒来。
6. TERMINATED（死亡状态、终止状态）：线程完成执行后的状态。线程执行完run()方
法中的全部代码，从该方法中退出，进入TERMINATED状态。还有一种情况是run()在运行
过程中抛出了一个异常，而这个异常没有被程序捕获，导致这个线程异常终止进入
TERMINATED状态。
在Java5.0及以上版本中，线程的全部六种状态都以枚举类型的形式定义在java.lang.Thread
类中了，代码如下：

public enum State {   
NEW,   
RUNNABLE,   
BLOCKED,   
WAITING,   
TIMED_WAITING,   
TERMINATED;   
}  

sleep与wait的区别
sleep()方法和wait()方法都成产生让当前运行的线程停止运行的效果
sleep方法是本地方法，属于Thread
public static native void sleep(long millis) throws InterruptedException;  
public static void sleep(long millis, int nanos) throws InterruptedException {  
//other code  
} 

其中的参数millis代表毫秒数（千分之一秒），nanos代表纳秒数（十亿分之一秒）。这两
个方法都可以让调用它的线程沉睡（停止运行）指定的时间，到了这个时间，线程就会自动
醒来，变为可运行状态（RUNNABLE），但这并不表示它马上就会被运行，因为线程调度
机制恢复线程的运行也需要时间。调用sleep()方法并不会让线程释放它所持有的同步锁；而
且在这期间它也不会阻碍其它线程的运行。上面的连个方法都声明抛出一个
InterruptedException类型的异常，这是因为线程在sleep()期间，有可能被持有它的引用的其它线程调用它的 interrupt()方法而中断。中断一个线程会导致一个InterruptedException异常的产生，如果你的程序不捕获这个异常，线程就会异常终止，进入TERMINATED状态，如果你的程序捕获了这个异常，那么程序就会继续执行catch语句块（可能还有finally语句块）以及以后的代码。

public class InterruptTest {   
public static void main(String[] args) {   
Thread t = new Thread() {   
public void run() {   
try {   
System.out.println("我被执行了-在sleep()方法前");   
// 停止运行10分钟   
Thread.sleep(1000 * 60 * 60 * 10);   
System.out.println("我被执行了-在sleep()方法后");   
} catch (InterruptedException e) {   
System.out.println("我被执行了-在catch语句块中");   
}   
System.out.println("我被执行了-在try{}语句块后");   
}   
};   
// 启动线程   
t.start();   
// 在sleep()结束前中断它   
t.interrupt();   
}   
} 

我被执行了-在sleep()方法前
我被执行了-在catch语句块中
我被执行了-在try{}语句块后

wait方法也是本地方法，属于Object类，有三个定义：

public final void wait() throws InterruptedException {   
//do something   
}   
public final native void wait(long timeout) throws InterruptedException;   
public final void wait(long timeout, int nanos) throws InterruptedException {   
//do something   
}  

wait()和wait(long timeout,int nanos)方法都是基于wait(long timeout)方法实现的。同样地，timeout代表毫秒数，nanos代表纳秒数。当调用了某个对象的wait()方法时，当前运行的线程就会转入等待状态（WAITING），等待别的线程再次调用这个对象的notify()或者notifyAll()方法（这两个方法也是本地方法）唤醒它，或者到了指定的最大等待时间，线程自动醒来。如果线程拥有某个或某些对象的同步锁，那么在调用了wait()后，这个线程就会释放它持有的所有同步资源，而不限于这个被调用了wait()方法的对象。wait()方法同样会被Thread类的interrupt()方法中断，并产生一个 InterruptedException异常，效果同sleep()方法被中断一样。
如何同步同步的使用可以保证在多线程运行的环境中，程序不会产生设计之外的错误结果。同步的实现方式有两种，同步方法和同步块，这两种方式都要用到synchronized关键字。
给一个方法增加synchronized修饰符之后就可以使它成为同步方法，这个方法可以是静态方
法和非静态方法，但是不能是抽象类的抽象方法，也不能是接口中的接口方法。
线程在执行同步方法时是具有排它性的。当任意一个线程进入到一个对象的任意一个同步方
法时，这个对象的所有同步方法都被锁定了，在此期间，其他任何线程都不能访问这个对象
的任意一个同步方法，直到这个线程执行完它所调用的同步方法并从中退出，从而导致它释
放了该对象的同步锁之后。在一个对象被某个线程锁定之后，其他线程是可以访问这个对象
的所有非同步方法的。
同步块的形式虽然与同步方法不同，但是原理和效果是一致的。同步块是通过锁定一个指定
的对象，来对同步块中包含的代码进行同步；而同步方法是对这个方法块里的代码进行同步，
而这种情况下锁定的对象就是同步方法所属的主体对象自身。如果这个方法是静态同步方法
呢？那么线程锁定的就不是这个类的对象了，也不是这个类自身，而是这个类对应的
java.lang.Class类型的对象。同步方法和同步块之间的相互制约只限于同一个对象之间，所以静态同步方法只受它所属类的其它静态同步方法的制约，而跟这个类的实例（对象）没有
关系。

public void test() {   
// 同步锁   
String lock = "LOCK";   
// 同步块   
synchronized (lock) {   
// do something   
}   
int i = 0;   
// ...   
}  

对于作为同步锁的对象并没有什么特别要求，任意一个对象都可以。如果一个对象既有同步
方法，又有同步块，那么当其中任意一个同步方法或者同步块被某个线程执行时，这个对象
就被锁定了，其他线程无法在此时访问这个对象的同步方法，也不能执行同步块。

synchronized和Lock
Lock是一个接口，它位于Java 5.0新增的java.utils.concurrent包的子包locks中。
Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。此实现允许更灵活的结构，可以具有差别很大的属性，可以支持多个相关的 Condition 对象。

锁是控制多个线程对共享资源进行访问的工具。通常，锁提供了对共享资源的独占访问。一次只能有一个线程获得锁，对共享资源的所有访问都需要首先获得锁。不过，某些锁可能允许对共享资源并发访问，如 ReadWriteLock 的读取锁。
concurrent包及其子包中的类都是用来处理多线程编程的。实现 Lock接口的类具有与synchronized关键字同样的功能，但是它更加强大一些。 java.utils.concurrent.locks.ReentrantLock是较常用
的实现了Lock接口的类。下面是 ReentrantLock类的一个应用实例：

private Lock lock = new ReentrantLock();   
public void testLock() {   
// 锁定对象,获取锁   
lock.lock();   
try {   
// do something   
} finally {   
// 释放对对象的锁定，释放锁   
lock.unlock();   
}   
}

使用synchronized关键字实现的同步，会把一个对象的所有同步方法和同步块看做一个整体，只要有一个被某个线程调用了，其他的就无法被别的线程执行，即使这些方法或同步块与被调用的代码之间没有任何逻辑关系，这显然降低了程序的运行效率。而使用Lock就能够很
好地解决这个问题。我们可以把一个对象中按照逻辑关系把需要同步的方法或代码进行分组，
为每个组创建一个Lock类型的对象，对实现同步。那么，当一个同步块被执行时，这个线
程只会锁定与当前运行代码相关的其他代码最小集合，而并不影响其他线程对其余同步代码
的调用执行。

死锁
死锁就是一个进程中的每个线程都在等待这个进程中的其他线程释放所占用的资源，从而导
致所有线程都无法继续执行的情况。
死锁的必要条件：
1. 互斥（Mutual exclusion）：线程所使用的资源中至少有一个是不能共享的，它在同一
时刻只能由一个线程使用。
2. 持有与等待（Hold and wait）：至少有一个线程已经持有了资源，并且正在等待获取
其他的线程所持有的资源。
3. 非抢占式（No pre-emption）：如果一个线程已经持有了某个资源，那么在这个线程释
放这个资源之前，别的线程不能把它抢夺过去使用。
4. 循环等待（Circular wait）：假设有N个线程在运行，第一个线程持有了一个资源，并
且正在等待获取第二个线程持有的资源，而第二个线程正在等待获取第三个线程持有的资源，
依此类推……第N个线程正在等待获取第一个线程持有的资源，由此形成一个循环等待。

线程池
线程池就像数据库连接池一样，是一个对象池。所有的对象池都有一个共同的目的，那就是
为了提高对象的使用率，从而达到提高程序效率的目的。比如对于Servlet，它被设计为多线
程的（如果它是单线程的，你就可以想象，当1000个人同时请求一个网页时，在第一个人
获得请求结果之前，其它999个人都在郁闷地等待），如果为每个用户的每一次请求都创建
一个新的线程对象来运行的话，系统就会在创建线程和销毁线程上耗费很大的开销，大大降
低系统的效率。因此，Servlet多线程机制背后有一个线程池在支持，线程池在初始化初期就
创建了一定数量的线程对象，通过提高对这些对象的利用率，避免高频率地创建对象，从而
达到提高程序的效率的目的。

事实上Java5.0及以上版本已经为我们提供了线程池功能，无需再重新实现。这些类位于
java.util.concurrent包中。
Executors类提供了一组创建线程池对象的方法，常用的有一下几个：

public static ExecutorService newCachedThreadPool() {   
// other code   
}   
public static ExecutorService newFixedThreadPool(int nThreads) {   
// other code   
}   
public static ExecutorService newSingleThreadExecutor() {   
// other code   
}   

newCachedThreadPool()方法创建一个动态的线程池，其中线程的数量会根据实际需要来创建
和回收，适合于执行大量短期任务的情况；newFixedThreadPool(int nThreads)方法创建一个
包含固定数量线程对象的线程池，nThreads代表要创建的线程数，如果某个线程在运行的过
程中因为异常而终止了，那么一个新的线程会被创建和启动来代替它；而
newSingleThreadExecutor()方法则只在线程池中创建一个线程，来执行所有的任务。
这三个方法都返回了一个ExecutorService类型的对象。实际上，ExecutorService是一个接口，
它的submit()方法负责接收任务并交与线程池中的线程去运行。submit()方法能够接受
Callable和Runnable两种类型的对象。它们的用法和区别如下：
1. Runnable接口：继承Runnable接口的类要实现它的run()方法，并将执行任务的代码放
入其中，run()方法没有返回值。适合于只做某种操作，不关心运行结果的情况。
2. Callable接口：继承Callable接口的类要实现它的call()方法，并将执行任务的代码放入其中，call()将任务的执行结果作为返回值。适合于执行某种操作后，需要知道执行结果的情况。
无论是接收Runnable型参数，还是接收Callable型参数的submit()方法，都会返回一个
Future（也是一个接口）类型的对象。该对象中包含了任务的执行情况以及结果。调用
Future的boolean isDone()方法可以获知任务是否执行完毕；调用Object get()方法可以获得任务执行后的返回结果，如果此时任务还没有执行完，get()方法会保持等待，直到相应的任务执行完毕后，才会将结果返回。
我们用下面的一个例子来演示Java5.0中线程池的使用：

import java.util.concurrent.*;   
public class ExecutorTest {   
public static void main(String[] args) throws InterruptedException,   
ExecutionException {   
ExecutorService es = Executors.newSingleThreadExecutor();   
Future fr = es.submit(new RunnableTest());// 提交任务   
Future fc = es.submit(new CallableTest());// 提交任务   
// 取得返回值并输出   
System.out.println((String) fc.get());   
// 检查任务是否执行完毕   
if (fr.isDone()) {   
System.out.println("执行完毕-RunnableTest.run()");   
} else {   
System.out.println("未执行完-RunnableTest.run()");   
}   
// 检查任务是否执行完毕   
if (fc.isDone()) {   
System.out.println("执行完毕-CallableTest.run()");   
} else {   
System.out.println("未执行完-CallableTest.run()");   
}   
// 停止线程池服务   
es.shutdown();   
}   
}   
class RunnableTest implements Runnable {   
public void run() {   
System.out.println("已经执行-RunnableTest.run()");   
}   
}   
class CallableTest implements Callable {   
public Object call() {   
System.out.println("已经执行-CallableTest.call()");   
return "返回值-CallableTest.call()";   
}   
}  
[java] view plaincopyprint?
import java.util.concurrent.*;  
public class ExecutorTest {  
public static void main(String[] args) throws InterruptedException,  
ExecutionException {  
ExecutorService es = Executors.newSingleThreadExecutor();  
Future fr = es.submit(new RunnableTest());// 提交任务  
Future fc = es.submit(new CallableTest());// 提交任务  
// 取得返回值并输出  
System.out.println((String) fc.get());  
// 检查任务是否执行完毕  
if (fr.isDone()) {  
System.out.println("执行完毕-RunnableTest.run()");  
} else {  
System.out.println("未执行完-RunnableTest.run()");  
}  
// 检查任务是否执行完毕  
if (fc.isDone()) {  
System.out.println("执行完毕-CallableTest.run()");  
} else {  
System.out.println("未执行完-CallableTest.run()");  
}  
// 停止线程池服务  
es.shutdown();  
}  
}  
class RunnableTest implements Runnable {  
public void run() {  
System.out.println("已经执行-RunnableTest.run()");  
}  
}  
class CallableTest implements Callable {  
public Object call() {  
System.out.println("已经执行-CallableTest.call()");  
return "返回值-CallableTest.call()";  
}  
}   

已经执行-RunnableTest.run()
已经执行-CallableTest.call()
返回值-CallableTest.call()
执行完毕-RunnableTest.run()
执行完毕-CallableTest.run()
使用完线程池之后，需要调用它的shutdown()方法停止服务，否则其中的所有线程都会保持
运行，程序不会退出。