Java并发框架-Executor

引论

• 现代业务：任务多，数据量大
• 串行vs并行
  • 串行结构：顺序结构、选择结构、循环结构等
  • 并行编程：多线程
  • 难易程度：串行编程简单，并行编程困难
  • CPU变化：单个计算核频率下降，计算核数增多，整体性能变高
• 并行编程困难
  • 主要困难：任务分配和执行过程高度耦合
  • 如何控制粒度，切割任务
  • 如何分配给线程，监督线程执行过程（线程状态）
• 并行模式：
  • 主从模式(Master-Slave)：有一个主线程，其他都是从线程
  • Worker模式(Worker-Worker)：所有线程都是平等的，无中心化
• Java并发编程
  • Thread/Runnable/Thread组管理
  • Executor框架
  • Fork-Join框架

正文

线程组ThreadGroup

• 它是线程的集合
• 它是树形结构，大线程组可以包括小线程组
• 可以通过enumerate方法遍历组内的线程，对他们进行批量操作
• 能够有效管理多个线程，但是管理效率低，属于低层次的一种管理
• 没有解决“任务分配和执行过程高度耦合"的问题
• 重复 创建线程、关闭线程 操作，无法重用线程

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

package threadgroup;

import java.util.concurrent.TimeUnit;

public class Main {
   

	public static void main(String[] args) {
   

		// 创建线程组 及 Result对象，其中ThreadGroup是jdk的内置对象
		ThreadGroup threadGroup = new ThreadGroup("Searcher");
		Result result=new Result();//Result类是一个JavaBean，封装了name属性

		// 创建一个任务，10个线程创建及运行
		Searcher searchTask=new Searcher(result);
		/**
		搜索类Searcher是一个实现了Runnable接口的线程类。
		实现了run方法，获取了当前线程的名字，调用doTask方法
		doTask是一个能够工作一段时间的函数，随机为每个线程创建了一个休眠时间。
		**/
		for (int i=0; i<10; i++) {
   
			Thread thread = new Thread(threadGroup, searchTask);
			thread.start();//用循环，把10个线程创建后运行
			try {
   
				TimeUnit.SECONDS.sleep(1);
			} catch (InterruptedException e) {
   
				e.printStackTrace();
			}
		}
		System.out.println("====================");
		
		// 查看线程组消息
		System.out.printf("active 线程数量: %d\n",threadGroup.activeCount());//返回线程组里面有哪些还是处于活动状态的线程
		System.out.printf("线程组信息明细\n");
		threadGroup.list();//打印10个线程的信息
		System.out.println("===============");

		// 遍历线程组
		Thread[] threads=new Thread[threadGroup.activeCount()];
		threadGroup.enumerate(threads);//将线程组中active的线程拷贝到数组中，利用数组遍历方法，对线程进行一些操作
		for (int i=0; i<threadGroup.activeCount(); i++) {
   
			System.out.printf("Thread %s: %s\n",threads[i].getName(),threads[i].getState());
		}
		System.out.println("===============");

		// 如果活动线程数大于9个，即若没有睡眠的线程，则休眠
		waitFinish(threadGroup);
		
		// 否则的话，对数组中所有的线程发出interrupt信号，中断线程
		threadGroup.interrupt();
	}

	public static void waitFinish(ThreadGroup threadGroup) {
   
		while (threadGroup.activeCount()>9) {
   
			/**
			 * activeCount,返回线程组中还处于active的线程数(估计数)；
			 * enumerate,将线程组中active的线程拷贝到数组中；
			 * interrupt，对数组中所有的线程发出interrupt信号；
			 * list，打印线程中所有的线程信息
			 */
			try {
   
				TimeUnit.SECONDS.sleep(1);
			} catch (InterruptedException e) {
   
				e.printStackTrace();
			}
		}
	}
}

Result

package threadgroup;

/**
 * 搜索结果类，一个简单的Bean类
 *
 */
public class Result {
   
	
	private String name;	
	
	public String getName() {
   
		return name;
	}	
	public void setName(String name) {
   
		this.name = name;
	}
}

线程Searcher，实现了run方法，为创建的线程随机产生一个休眠时间

package threadgroup;

import java.util.Date;
import java.util.Random;
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.printf</