Java线程组

1 并行计算

  现在计算机所面临的业务特点：任务多，数据量大。尽管说我们的计算性能每18个月就翻一番，但是我们所处理的东西也越来越多，所以，在编程上面就有两种方法，串行编程和并行编程。

1.1 编程方法

• 串行编程：简单，多线程以前所学的程序都是串行编程
• 并行编程：困难，原因：任务分配和执行过程高度耦合

  由于单个计算核的频率下降，但是计算核数不断增加，整体性能实在变高的，这就迫使我们去采用这种并行编程的方式，才能提高我们的计算性能。

多线程编程我们需要研究的是：

• 如何控制粒度，切割任务
• 如何分配任务给线程，监督线程执行过程

1.2 并行模式

• 主从模式（Master-Slave）：一个主线程，其余的都是从线程。主线程会指挥从线程去工作，主线程起到一个协调的作用。

• Worker模式（Worker-Worker）：即Worker to Worker或Peer to Peer（P2P）。这种模式下面所有的线程都是平等的，无中心化的一种模式。

1.3 Java并发编程

• Thread、Runnable、Thread组管理（多个线程类）
• Executor框架（本节重点）
• Fork-Join框架

2 线程组管理ThreadGroup

  当我们的程序中线程很多了以后，这时一个一个的去管理就比较困难的，所以就提供了线程组的概念。

2.1 ThreaGroup

线程组只是提供一个数组的方式来方便的控制这些线程。

• 线程的集合，是一个树形机构，大线程可以包括小线程

• 可以通过enumerate方法遍历线程组内的线程，批量执行操作

• 能够管理多个线程，但是管理效率低

• 解决不了任务配和执行过程高度耦合的问题

• 线程组也解决不了重复创建线程，无法重用线程的问题

  线程和线程组内的线程都是new产生出来的，但是start以后就不能再使用（即在次start）了。new的代价很昂贵，只运行一次，性价比过低。

2.2 ThreaGroup如何应用

  下面的程序将展示如何应用线程组管理多个线程。

Main类

package com.antique.threadgroup;

import java.util.concurrent.TimeUnit;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // 创建线程组，Searcher 为线程组名称
        ThreadGroup threadGroup = new ThreadGroup("Search");
        Result result = new Result();

        // 创建一个任务，10个线程完成
        Searcher searchTask = new Searcher(result);
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(threadGroup, searchTask);
            thread.start();
            TimeUnit.SECONDS.sleep(1);
        }

        System.out.println("++++++++++++++++++++++++++++++++++++");
        // 查看线程组消息
        System.out.println("active 线程数量：" + threadGroup.activeCount());
        System.out.println("线程组信息明细");
        threadGroup.list();     // list 打印线程组中所有线程信息
        System.out.println("++++++++++++++++++++++++++++++++++++");

        // 遍历线程组
        Thread[] threads = new Thread[threadGroup.activeCount()];
        /* enumerate 将线程组中所有的active线程拷贝到数组中 */
        threadGroup.enumerate(threads);
        for (int i = 0; i < threadGroup.activeCount(); i++) {
            System.out.println(threads[i].getName() + ": " + threads[i].getState());
        }

        waitFinish(threadGroup);
        /* 一旦有一个线程完成了任务，就中断其他所有线程 */
        threadGroup.interrupt();
    }

    private static void waitFinish(ThreadGroup threadGroup) {
        /* main线程轮询检查是否有完成的线程 */
        while (threadGroup.activeCount() >= 10) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Searcher类：

package com.antique.threadgroup;
import java.util.concurrent.TimeUnit;

public class Searcher implements Runnable{
    private Result result;

    public Searcher(Result result) {
        this.result = result;
    }

    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        System.out.println(name + ": 启动");
        try {
            doTask();
            result.setName(name);
        } catch (InterruptedException e) {
            System.out.println(name + ": 被中断");
            return;
        }

        System.out.println(name + ": 完成");
    }

    /* 伪造一个认真工作的函数 实际上就是sleep一段时间 */
    private void doTask() throws InterruptedException {
        int value = (int)(Math.random() * 100);
        System.out.println(Thread.currentThread().getName() + ": " + value);
        TimeUnit.SECONDS.sleep(value);
    }
}

Result类：

package com.antique.threadgroup;

public class Result {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

运行结果截图：

  通过上面的程序可以看出，线程组只是提供给我们一种方式，可以遍历它所管理的所有线程。线程组的功能是比较有限的，它也没有解决任务分配和执行过程中的监督高度耦合的问题