JAVA多线程

ThreadPoolService（线程池服务类）：这是线程池最核心的一个类。它在被创建了时候就创建了几个线程对象，但是这些线程并没有启动运行，但调用了start()方法启动线程池服务时，它们才真正运行。stop()方法可以停止线程池服务，同时停止池中所有线程的运行。而runTask(Tasktask)方法是将一个新的待执行任务交与线程池来运行。
ThreadPoolService类的定义如下：

Java代码

1. import java.util.ArrayList;   
2. import java.util.List;   
3.   
4. public class ThreadPoolService {   
5.     // 线程数   
6.     public static final int THREAD_COUNT = 5;   
7.   
8.     // 线程池状态   
9.     private Status status = Status.NEW;   
10.   
11.     private TaskQueue queue = new TaskQueue();   
12.   
13.     public enum Status {   
14.         /* 新建 */NEW, /* 提供服务中 */RUNNING, /* 停止服务 */TERMINATED,   
15.      }   
16.   
17.     private List<Thread> threads = new ArrayList<Thread>();   
18.   
19.     public ThreadPoolService() {   
20.         for (int i = 0; i < THREAD_COUNT; i++) {   
21.              Thread t = new TaskThread(this);   
22.              threads.add(t);   
23.          }   
24.      }   
25.   
26.     // 启动服务   
27.     public void start() {  

[/list]
完成了上面四个类，我们就实现了一个简单的线程池。现在我们就可以使用它了，下面的代码做了一个简单的示例：

Java代码

1. public class SimpleTaskTest extends Task {   
2.     @Override  
3.     public void deal() {   
4.         // do something   
5.      }   
6.   
7.     public static void main(String[] args) throws InterruptedException {   
8.          ThreadPoolService service = new ThreadPoolService();   
9.          service.start();   
10.         // 执行十次任务   
11.         for (int i = 0; i < 10; i++) {   
12.              service.runTask(new SimpleTaskTest());   
13.          }   
14.         // 睡眠1秒钟，等待所有任务执行完毕   
15.          Thread.sleep(1000);   
16.          service.stop();   
17.      }   
18. }  

public class SimpleTaskTest extends Task {

 @Override

 public void deal() {

  // do something

 }

 

 public static void main(String[] args) throws InterruptedException {

  ThreadPoolService service = new ThreadPoolService();

  service.start();

  // 执行十次任务

  for (int i = 0; i < 10; i++) {

   service.runTask(new SimpleTaskTest());

  }

  // 睡眠1秒钟，等待所有任务执行完毕

  Thread.sleep(1000);

  service.stop();

 }

}

当然，我们实现的是最简单的，这里只是为了演示线程池的实现原理。在实际应用中，根据情况的不同，可以做很多优化。比如：

• 调整任务队列的规则，给任务设置优先级，级别高的任务优先执行。
• 动态维护线程池，当待执行任务数量较多时，增加线程的数量，加快任务的执行速度；当任务较少时，回收一部分长期闲置的线程，减少对系统资源的消耗。

事实上Java5.0及以上版本已经为我们提供了线程池功能，无需再重新实现。这些类位于java.util.concurrent包中。

Executors类提供了一组创建线程池对象的方法，常用的有一下几个：

Java代码

1. public static ExecutorService newCachedThreadPool() {   
2.     // other code   
3. }   
4.   
5. public static ExecutorService newFixedThreadPool(int nThreads) {   
6.     // other code   
7. }   
8.   
9. public static ExecutorService newSingleThreadExecutor() {   
10.     // other code   
11. }  

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中线程池的使用：

Java代码

1. import java.util.concurrent.*;   
2.   
3. public class ExecutorTest {   
4.     public static void main(String[] args) throws InterruptedException,   
5.              ExecutionException {   
6.          ExecutorService es = Executors.newSingleThreadExecutor();   
7.          Future fr = es.submit(new RunnableTest());// 提交任务   
8.   
9.          Future fc = es.submit(new CallableTest());// 提交任务   
10.         // 取得返回值并输出   
11.          System.out.println((String) fc.get());   
12.   
13.         // 检查任务是否执行完毕   
14.         if (fr.isDone()) {   
15.              System.out.println("执行完毕-RunnableTest.run()");   
16.          } else {   
17.              System.out.println("未执行完-RunnableTest.run()");   
18.          }   
19.   
20.         // 检查任务是否执行完毕   
21.         if (fc.isDone()) {   
22.              System.out.println("执行完毕-CallableTest.run()");   
23.          } else {   
24.              System.out.println("未执行完-CallableTest.run()");   
25.          }   
26.   
27.         // 停止线程池服务   
28.          es.shutdown();   
29.      }   
30. }   
31.   
32. class RunnableTest implements Runnable {   
33.     public void run() {   
34.          System.out.println("已经执行-RunnableTest.run()");   
35.      }   
36. }   
37.   
38. class CallableTest implements Callable {   
39.     public Object call() {   
40.          System.out.println("已经执行-CallableTest.call()");   
41.         return "返回值-CallableTest.call()";   
42.      }   
43. }  

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()";

 }

}

运行结果：

1. 已经执行-RunnableTest.run()
2. 已经执行-CallableTest.call()
3. 返回值-CallableTest.call()
4. 执行完毕-RunnableTest.run()
5. 执行完毕-CallableTest.run()

      使用完线程池之后，需要调用它的shutdown()方法停止服务，否则其中的所有线程都会保持运行，程序不会退出。

                                                                                                              （转载http://zangweiren.javaeye.com ）