线程组管理

线程组：

线程的集合
大线程可包含小线程、
可管理多个线程，但效率较低
重复的创建线程和关闭线程
可通过enumerate显示所有线程

例：
使用线程组创建10个线程，每创建一个线程，休息1秒。
输出活跃的线程，所有线程列表。当活跃的线程数少于8个时，终止所有的线程。

其中，Reacher类为实现Runnable接口的类，Result类为一个存储数据的类。

package ThreadGroup;import java.util.concurrent.TimeUnit;public class Main {public static void main(String[] args) {ThreadGroup  threadgroup = new ThreadGroup("Peter");Result result = new Result(null);Reacher reacher = new Reacher(result);int i = 0;for(; i < 10; i++) {Thread thread = new Thread(threadgroup, reacher);thread.start();try {TimeUnit.SECONDS.sleep(1);}catch(InterruptedException e) {e.printStackTrace();}}System.out.println("=========线程组创建完成==========");System.out.println("活跃的线程数量为：" + threadgroup.activeCount());System.out.println("所有线程为：");threadgroup.list();System.out.println("===============================");Thread[] threads = new Thread[threadgroup.activeCount()];threadgroup.enumerate(threads);//将线程组中所有活跃的线程copy到数组中for(i = 0; i < threadgroup.activeCount(); i++)System.out.println(threads[i].getName() +": " + threads[i].getState());System.out.println("===============================");waitfinish(threadgroup);threadgroup.interrupt();}public static void waitfinish(ThreadGroup threadgroup) {while(threadgroup.activeCount() > 8) {try {TimeUnit.SECONDS.sleep(1);}catch(InterruptedException e) {e.printStackTrace();}}}
}package ThreadGroup;import java.util.Date;
import java.util.Random;
import java.util.concurrent.TimeUnit;public class Reacher implements Runnable{private Result result;public Reacher(Result result) {this.result = result;}public void run() {String name = Thread.currentThread().getName();System.out.println("Thread" + name + "启动");try {doTask();result.setName(name);} catch (InterruptedException e) {e.printStackTrace();}}private void doTask() throws InterruptedException {Random random = new Random((new Date()).getTime());int value = (int)(random.nextDouble()*50);System.out.printf("Thread %s : %d\n", Thread.currentThread().getName(), value);TimeUnit.SECONDS.sleep(value);}
}package ThreadGroup;public class Result {public String name;public Result(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}
}

Executor 框架

该框架可分离认任务的创建和任务的执行，线程可重复利用。（new开销大）

共享线程池：

预设好多个线程，多次执行多个小任务；
无需关心其他线程的执行过程；
任务创建与执行解耦合。

主要类：
ExecutorService，ThreadPoolExecutor，Future。
创建线程池：Executors.newCachedThreadPool/newFixedThreadPool。
线程池服务：ExecutorService。
具体的逻辑对象：Callable。
输出结果：Future。

例子：
main方法中：创建线程池，10个线程，创建线程安全的列表存储结果。
SumTask是一个实现Callable的接口。
（Callable与Runnabl基本一致，只是在实现的call方法中有返回值。）
SumTask类计算某一段的数据和，并返回。
依次创建并将该线程加入到线程池中。
当所有线程都完成后，计算总和。

package executor;
import java.util.concurrent.Future;
import java.util.ArrayList;import java.util.Collections;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;public class TestTask {public static void main(String[] args) throws InterruptedException, ExecutionException {ThreadPoolExecutor executor = (ThreadPoolExecutor)Executors.newFixedThreadPool(10);List<Future<Integer>> resultList = Collections.synchronizedList(new ArrayList<Future<Integer>>());int i;for(i = 0; i < 10; i++) {SumTask caculator = new SumTask(i*100+1, (i+1)*100 + 1);Future<Integer> result = executor.submit(caculator);resultList.add(result);}do {System.out.println("已完成的任务数：" + executor.getCompletedTaskCount());for(i = 0; i < resultList.size(); i++) {Future<Integer> result = resultList.get(i);System.out.printf("Task %d: %s\n", i, result.isDone());try {Thread.sleep(50);}catch(InterruptedException e) {e.printStackTrace();}}}while(executor.getCompletedTaskCount() < resultList.size());int total = 0;for(i = 0; i < resultList.size(); i++) {Future<Integer> result = resultList.get(i);total += result.get();}System.out.println("1-1000的总和为：" + total);  executor.shutdown();}
}package executor;import java.util.concurrent.Callable;public class SumTask implements Callable<Integer>{private int startNum;private int endNum;public SumTask(int startNum, int endNum) {this.startNum = startNum;this.endNum = endNum;}@Overridepublic Integer call() throws Exception {int sum = 0;for(int i = startNum; i < endNum+1; i++) {sum = sum + i;}System.out.println(Thread.currentThread().getName() + "的和为：" + sum);return sum;}
}

Fork-Join框架

该框架适用于整体任务量不确定的场合。实现分治编程（分解，治理合并）。

关键类：
ForkJoinPool：任务池。
定义具体的任务：
RecursiveAction，RecursiveTask。

框架实现步骤：

创建线程池；
创建任务；
提交任务，获取结果；
监视过程；
输出结果。

例子：
创建线程池，个数为8。
创建任务，并且提交任务，只需提交一次。

在SumTask线程中，继承RecursiveTask，实现compute方法。
依照分解的思路逐步展开，并不断提交任务。

package ForkJoin;import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;public class MainTask {public static void main(String[] args) throws InterruptedException, ExecutionException {ForkJoinPool pool =  new ForkJoinPool(8);SumTask task = new SumTask(1, 1000000);ForkJoinTask<Long> result = pool.submit(task);do {System.out.println("正在活跃的线程数：" + pool.getActiveThreadCount());System.out.println("正在并行的线程数：" + pool.getParallelism());   try {Thread.sleep(50);}catch(InterruptedException e) {e.printStackTrace();}}while(!result.isDone());System.out.println("1-100000d的和为：" + result.get().toString());}
}//任务线程
package ForkJoin;import java.util.concurrent.RecursiveTask;public class SumTask extends RecursiveTask<Long>{private static final long serialVersionUID = 1L;private int start;private int end;public SumTask(int s, int e) {start = s;end = e;}@Overrideprotected Long compute() {Long sum = (long) 0;int threadhold = 4;if((end - start) < threadhold) {for(int i = start; i < end + 1; i++) sum += i;}else {int mid = (end - start)/2 + start;SumTask task1 = new SumTask(start, mid);SumTask task2 = new SumTask(mid + 1, end);invokeAll(task1, task2);//提交自任务Long sum1 = task1.join();//等待子任务完成。Long sum2 = task2.join();sum = sum1 + sum2;}return sum;}
}

java 并发编程框架相关推荐

Java并发编程框架Disruptor
Disruptor是什么? Disruptor是一个高性能的异步处理框架,一个轻量级的JMS,和JDK中的BlockingQueue有相似处,但是它的处理速度非常快,获得2011年程序框架创新大奖,号 ...
Java 并发编程——Executor框架和线程池原理
Java 并发编程系列文章 Java 并发基础--线程安全性 Java 并发编程--Callable+Future+FutureTask java 并发编程--Thread 源码重新学习 java并发 ...
Java并发编程实战————Executor框架与任务执行
引言本篇博客介绍通过"执行任务"的机制来设计应用程序时需要掌握的一些知识.所有的内容均提炼自<Java并发编程实战>中第六章的内容. 大多数并发应用程序都是围绕&qu ...
Java并发编程(08)：Executor线程池框架
本文源码:GitHub·点这里 || GitEE·点这里一.Executor框架简介 1.基础简介 Executor系统中,将线程任务提交和任务执行进行了解耦的设计,Executor有各种功能强大的 ...
java 并发框架源码_某网Java并发编程高阶技术-高性能并发框架源码解析与实战（云盘下载）...
第1章课程介绍(Java并发编程进阶课程) 什么是Disruptor?它一个高性能的异步处理框架,号称"单线程每秒可处理600W个订单"的神器,本课程目标:彻底精通一个如此优秀的 ...
《Java并发编程的艺术》——Java中的并发工具类、线程池、Execute框架（笔记）
文章目录八.Java中的并发工具类 8.1 等待多线程完成的CountDownLatch 8.2 同步屏障CyclicBarrier 8.2.1 CyclicBarrier简介 8.2.2 Cycl ...
Java并发编程71道面试题及答案
Java并发编程71道面试题及答案 1.在java中守护线程和本地线程区别? java中的线程分为两种:守护线程(Daemon)和用户线程(User). 任何线程都可以设置为守护线程和用户线程,通过方 ...
Java并发编程有多难？这几个核心技术你掌握了吗？
本文主要内容索引 1.Java线程 2.线程模型 3.Java线程池 4.Future(各种Future) 5.Fork/Join框架 6.volatile 7.CAS(原子操作) 8.AQS(并发同 ...
Java并发编程75道面试题及答案
1.在java中守护线程和本地线程区别?java中的线程分为两种:守护线程(Daemon)和用户线程(User).任何线程都可以设置为守护线程和用户线程,通过方法Thread.setDaemon(bo ...

java 并发编程框架

java 并发编程

线程组管理

Executor 框架

Fork-Join框架

java 并发编程框架相关推荐

最新文章

热门文章