现在的位置: 首页 > 综合 > 正文

Java7并发示例集110:线程组

2014年01月13日 ⁄ 综合 ⁄ 共 6216字 ⁄ 字号 评论关闭
文章目录

线程分组是Java并发API提供的一个有趣功能。我们可以将一组线程看成一个独立单元,并且可以随意操纵线程组中的线程对象。比如,可以控制一组线程来运行同样的任务,无需关心有多少线程还在运行,还可以使用一次中断调用中断所有线程的执行。

Java提供了ThreadGroup类来控制一个线程组。一个线程组可以通过线程对象来创建,也可以由其他线程组来创建,生成一个树形结构的线程。

根据《Effective Java》的说明,不再建议使用ThreadGroup。建议使用Executor

——D瓜哥特此说明。

在本节,我们就使用ThreadGroup来开发一个简单的示例。我们将创建十个休眠时间不等的线程(比如模拟搜索),当其中一个完成时,中断其余线程。

知其然

按照下面所示步骤,完成示例代码。

  1. 创建一个名为Result的类,用于存储第一个完成任务的线程的名字。声明一个String类型的私有变量,name,同时生成Setter/Getter方法。代码如下:

    01 public
    class
    Result {
    02     private
    String name;
    03
    04     public
    String getName() {
    05         return
    name;
    06     }
    07
    08     public
    void setName(String name) {
    09         this.name = name;
    10     }
    11 }
  2. 创建一个名为SearchTask的类,并实现Runnable接口。代码如下:

    1 public
    class
    SearchTask implements
    Runnable {
  3. 声明一个Result类型的私有变量,并通过构造函数来实例化该变量。代码如下:

    1 private
    Result result;
    2 public
    SearchTask(Result result) {
    3     this.result = result;
    4 }
  4. 实现run()方法,在其中调用doTask()方法,来等待完成或被中断。该方法还向控制台打印信息来显示线程的开始、结束或者中断。代码如下:

    01 @Override
    02 public
    void
    run() {
    03     String name = Thread.currentThread().getName();
    04     System.out.printf("Thread %s: Start\n", name);
    05     try
    {
    06         doTask();
    07         result.setName(name);
    08     }
    catch (InterruptedException e) {
    09         System.out.printf("Thread %s: Interrupted\n", name);
    10         return;
    11     }
    12     System.out.printf("Thread %s: End\n", name);
    13 }
  5. 实现doTask()方法,该方法将创建一个Random对象,然后使用该对象生成一个随机数,来调节线程休眠的时间。代码如下:

    1 // 模拟搜索
    2 private
    void
    doTask() throws
    InterruptedException {
    3     Random random =
    new Random(new
    Date().getTime());
    4     int
    value = (int) (random.nextDouble() *
    100);
    5     System.out.printf("Thread %s: %d\n",
    6             Thread.currentThread().getName(), value);
    7     TimeUnit.SECONDS.sleep(value);
    8 }
  6. 创建示例程序的主类,Main,并实现main()方法。代码如下:

    1 public
    class
    Main {
    2     public
    static void
    main(String[] args) {
  7. 创建一个名称为SearcherThreadGroup对象。代码如下:

    1 ThreadGroup threadGroup = new
    ThreadGroup("Searcher");
  8. 然后,创建一个Result对象和SearchTask对象。代码如下:

    1 Result result = new
    Result();
    2 SearchTask searchTask = new
    SearchTask(result);
  9. SearchTask对象使用创建十个Thread对象,并且创建Thread对象时,将ThreadGroup对象作为第一个参数,传递给Thread类的构造函数。代码如下:

    1 for
    (
    int i =
    0; i < 5; i++) {
    2     Thread thread =
    new Thread(threadGroup, searchTask);
    3     thread.start();
    4     try
    {
    5         TimeUnit.SECONDS.sleep(1);
    6     }
    catch (InterruptedException e) {
    7         e.printStackTrace();
    8     }
    9 }
  10. 使用list()方法将ThreadGroup对象的信息打印出来。代码如下:

    1 System.out.printf("Number of Threads: %d\n", threadGroup.activeCount());
    2 System.out.println("Information about the Thread Group");
    3 threadGroup.list();
  11. 使用activeCount()enumerate()来获取ThreadGroup对象中的活跃线程数并将其复制到一个线程数组中。使用get*()方法,获取线程的名称和状态。代码如下:

    1 Thread[] threads = new
    Thread[threadGroup.activeCount()];
    2 threadGroup.enumerate(threads);
    3 for
    (
    int i =
    0; i < threadGroup.activeCount(); i++) {
    4     System.out.printf("Thread %s: %s\n", threads[i].getName(),
    5             threads[i].getState());
    6 }
  12. 调用waitFinish()方法,等待ThreadGroup对象中的其中一个线程完成任务。稍后实现该方法。代码如下:

    1 waitFinish(threadGroup);
  13. 使用interrupt()方法,中断线程组中其他线程。代码如下:

    1 threadGroup.interrupt();
  14. 实现waitFinish()方法,使用activeCount()方法控制线程的执行结果。代码如下:

    01 // 等待任务完成
    02 private
    static
    void waitFinish(ThreadGroup threadGroup) {
    03     while
    (threadGroup.activeCount() > 9) {
    04         try
    {
    05             TimeUnit.SECONDS.sleep(1);
    06         }
    catch (InterruptedException e) {
    07             e.printStackTrace();
    08         }
    09     }
    10 }
  15. 运行程序,查看执行效果。

知其所以然

下面是程序执行的结果。你将看到list()方法的输出,各个线程的状态等。

01 Thread Thread-0: Start
02 Thread Thread-0:
52
03 Thread Thread-1: Start
04 Thread Thread-1:
41
05 Thread Thread-2: Start
06 Thread Thread-2:
69
07 Thread Thread-3: Start
08 Thread Thread-3:
60
09 Thread Thread-4: Start
10 Thread Thread-4:
88
11 Number of Threads: 5
12 Information about the Thread Group
13 java.lang.ThreadGroup[name=Searcher,maxpri=10]
14     Thread[Thread-0,5,Searcher]
15     Thread[Thread-1,5,Searcher]
16     Thread[Thread-2,5,Searcher]
17     Thread[Thread-3,5,Searcher]
18     Thread[Thread-4,5,Searcher]
19 Thread Thread-0: TIMED_WAITING
20 Thread Thread-1: TIMED_WAITING
21 Thread Thread-2: TIMED_WAITING
22 Thread Thread-3: TIMED_WAITING
23 Thread Thread-4: TIMED_WAITING
24 Thread Thread-1: Interrupted
25 Thread Thread-4: Interrupted
26 Thread Thread-2: Interrupted
27 Thread Thread-0: Interrupted
28 Thread Thread-3: Interrupted

ThreadGroup类保存着众多Thread对象以及关联的ThreadGroup对象。可以通过调用该类的方法,访问线程的信息,还可以对其进行各种操作,比如中断等。

永无止境

ThreadGroup类还有好多方法。请翻阅API文档,查看完整的方法说明。

拿来主义

本文是从 《Java 7 Concurrency Cookbook》 (D瓜哥窃译为 《Java7并发示例集》 )翻译而来,仅作为学习资料使用。没有授权,不得用于任何商业行为。

小有所成

下面是本节示例所用的代码的完整版。

Result类的完整代码

01 package
com.diguage.books.concurrencycookbook.chapter1.recipe10;
02
03 /**
04 * 存储查询结果
05 * <p/>
06 * Coder: D瓜哥,http://www.diguage.com/
07 * Date: 2013-09-30
08 * Time: 00:45
09 */
10 public
class
Result {
11     private
String name;
12
13     public
String getName() {
14         return
name;
15     }
16
17     public
void setName(String name) {
18         this.name = name;
19     }
20 }

SearchTask类的完整代码

01 package
com.diguage.books.concurrencycookbook.chapter1.recipe10;
02
03 import
java.util.Date;
04 import
java.util.Random;
05 import
java.util.concurrent.TimeUnit;
06
07 /**
08 * 模拟搜索类
09 * <p/>
10 * Coder: D瓜哥,http://www.diguage.com/
11 * Date: 2013-10-02
12 * Time: 22:38
13 */
14 public
class
SearchTask implements
Runnable {
15     private
Result result;
16
17     public
SearchTask(Result result) {
18         this.result = result;
19     }
20
21     @Override
22     public
void run() {
23         String name = Thread.currentThread().getName();
24         System.out.printf("Thread %s: Start\n", name);
25         try
{
26             doTask();
27             result.setName(name);
28         }
catch (InterruptedException e) {
29             System.out.printf("Thread %s: Interrupted\n", name);
30             return;
31         }
32         System.out.printf("Thread %s: End\n", name);
33     }
34
35     // 模拟搜索
36     private
void doTask() throws
InterruptedException {
37         Random random =
new Random(new
Date().getTime());
38         int
value = (int) (random.nextDouble() *
100);
39         System.out.printf("Thread %s: %d\n",
40                 Thread.currentThread().getName(), value);
41         TimeUnit.SECONDS.sleep(value);
42     }
43 }

Main类的完整代码

01 package
com.diguage.books.concurrencycookbook.chapter1.recipe10;
02
03 import
java.util.concurrent.TimeUnit;
04
05 /**
06 * 线程组示例主类
07 * <p/>
08 * Coder: D瓜哥,http://www.diguage.com/
09 * Date: 2013-10-02
10 * Time: 22:45
11 */
12 public
class
Main {
13     public
static void
main(String[] args) {
14         ThreadGroup threadGroup =
new ThreadGroup("Searcher");
15
16         Result result =
new Result();
17         SearchTask searchTask =
new SearchTask(result);
18
19         for
(int
i =
0; i <
5; i++) {
20             Thread thread =
new Thread(threadGroup, searchTask);
21             thread.start();
22

抱歉!评论已关闭.