java多线程并发执行demo,主线程阻塞
其中有四个知识点我单独罗列了出来,属于多线程编程中需要知道的知识:
知识点1:X,T为泛型,为什么要用泛型,泛型和Object的区别请看:https://www.cnblogs.com/xiaoxiong2015/p/12705815.html
知识点2:线程池:https://www.cnblogs.com/xiaoxiong2015/p/12706153.html
知识点3:队列:@author Doug Lea https://www.cnblogs.com/xiaoxiong2015/p/12825636.html
知识点4:计数器,还是并发包大神 @author Doug Lea 编写。是一个原子安全的计数器,可以利用它实现发令枪
Doug Lea真是大神,编程不识Doug Lea,写尽Java也枉然,concurrent包点进去,都是他写的。可能是需要什么东西就写了吧,信手拈来的感觉。
主类:MultiThread,执行并发类
package java8test; import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue; /**
* @param <H> 为被处理的数据类型
* @param <T>返回数据类型
* 知识点1:X,T为泛型,为什么要用泛型,泛型和Object的区别请看:https://www.cnblogs.com/xiaoxiong2015/p/12705815.html
*/
public abstract class MultiThread<X, T> { public static int i = 0; // 知识点2:线程池:https://www.cnblogs.com/xiaoxiong2015/p/12706153.html
private final ExecutorService exec; // 线程池 // 知识点3:@author Doung Lea 队列:https://www.cnblogs.com/xiaoxiong2015/p/12825636.html
private final BlockingQueue<Future<T>> queue = new LinkedBlockingQueue<>(); // 知识点4:计数器,还是并发包大神 @author Doug Lea 编写。是一个原子安全的计数器,可以利用它实现发令枪
private final CountDownLatch startLock = new CountDownLatch(1); // 启动门,当所有线程就绪时调用countDown private final CountDownLatch endLock; // 结束门 private final List<X> listData;// 被处理的数据 /**
* @param list list.size()为多少个线程处理,list里面的H为被处理的数据
*/
public MultiThread(List<X> list) {
if (list != null && list.size() > 0) {
this.listData = list;
exec = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors()); // 创建线程池,线程池共有nThread个线程
endLock = new CountDownLatch(list.size()); // 设置结束门计数器,当一个线程结束时调用countDown
} else {
listData = null;
exec = null;
endLock = null;
}
} /**
*
* @return 获取每个线程处理结速的数组
* @throws InterruptedException
* @throws ExecutionException
*/
public List<T> getResult() throws InterruptedException, ExecutionException { List<T> resultList = new ArrayList<>();
if (listData != null && listData.size() > 0) {
int nThread = listData.size(); // 线程数量
for (int i = 0; i < nThread; i++) {
X data = listData.get(i);
Future<T> future = exec.submit(new Task(i, data) { @Override
public T execute(int currentThread, X data) { return outExecute(currentThread, data);
}
}); // 将任务提交到线程池
queue.add(future); // 将Future实例添加至队列
}
startLock.countDown(); // 所有任务添加完毕,启动门计数器减1,这时计数器为0,所有添加的任务开始执行
endLock.await(); // 主线程阻塞,直到所有线程执行完成
for (Future<T> future : queue) {
resultList.add(future.get());
}
exec.shutdown(); // 关闭线程池
}
return resultList;
} /**
* 每一个线程执行的功能,需要调用者来实现
* @param currentThread 线程号
* @param data 每个线程被处理的数据
* @return T返回对象
*/
public abstract T outExecute(int currentThread, X data); /**
* 线程类
*/
private abstract class Task implements Callable<T> { private int currentThread;// 当前线程号 private X data; public Task(int currentThread, X data) {
this.currentThread = currentThread;
this.data = data;
} @Override
public T call() throws Exception { // startLock.await(); // 线程启动后调用await,当前线程阻塞,只有启动门计数器为0时当前线程才会往下执行
T t = null;
try {
t = execute(currentThread, data);
} finally {
endLock.countDown(); // 线程执行完毕,结束门计数器减1
}
return t;
} /**
* 每一个线程执行的功能
* @param currentThread 线程号
* @param data 每个线程被处理的数据
* @return T返回对象
*/
public abstract T execute(int currentThread, X data);
}
}
结果类:ResultVO,保存返回结果,根据实际情况替换成自己的
package java8test; public class ResultVo { int i; public ResultVo(int i) {
this.i = i;
} public ResultVo() {
// TODO Auto-generated constructor stub
} }
参数类:ParamVO,传入参数类,根据实际情况替换成自己的
package java8test; public class ParamVo { private int i; ParamVo(int i) {
this.i = i;
} public int getI() { return i;
} @Override
public String toString() { return String.valueOf(i) + " " + hashCode();
}
}
测试类:new两个MultiThread,可以看到MultiThread这个类不存在线程安全问题。
package java8test; import java.util.ArrayList;
import java.util.List; public class Test { public static void main(String[] args) { try {
List<ParamVo> splitList = new ArrayList<ParamVo>();
for (int i = 0; i < 100; i++) {
splitList.add(new ParamVo(i));
}
List<ParamVo> splitList1 = new ArrayList<ParamVo>();
for (int i = 200; i < 300; i++) {
splitList1.add(new ParamVo(i));
}
MultiThread<ParamVo, ResultVo> multiThread = new MultiThread<ParamVo, ResultVo>(splitList) { @Override
public ResultVo outExecute(int currentThread, ParamVo data) { System.out.println("当前线程名称:" + Thread.currentThread().getName() + "当前线程号=" + currentThread
+ " data=" + data);
i--;
return new ResultVo(data.getI());
}
}; MultiThread<ParamVo, ResultVo> multiThread1 = new MultiThread<ParamVo, ResultVo>(splitList1) { @Override
public ResultVo outExecute(int currentThread, ParamVo data) { System.out.println("当前线程名称:" + Thread.currentThread().getName() + "当前线程号=" + currentThread
+ " data=" + data);
i--;
return new ResultVo(data.getI());
}
};
List<ResultVo> list = multiThread.getResult();
List<ResultVo> list1 = multiThread1.getResult();
// 获取每一批次处理结果
System.out.println("获取处理结果........................");
for (ResultVo vo : list) {
System.out.println(vo.i);
}
System.out.println("获取1处理结果........................");
for (ResultVo vo : list1) {
System.out.println(vo.i);
}
} catch (Exception e) {
e.printStackTrace();
} } }
这个类也用在了生产当中,用来并发插入数据。但是事务不能被管控,需要自己保证最终事务一致。需要注意。
java多线程并发执行demo,主线程阻塞的更多相关文章
- 多线程并发执行任务,取结果归集。终极总结:Future、FutureTask、CompletionService、CompletableFuture
目录 1.Futrue 2.FutureTask 3.CompletionService 4.CompletableFuture 5.总结 ================正文分割线========= ...
- Java 多线程并发编程一览笔录
Java 多线程并发编程一览笔录 知识体系图: 1.线程是什么? 线程是进程中独立运行的子任务. 2.创建线程的方式 方式一:将类声明为 Thread 的子类.该子类应重写 Thread 类的 run ...
- Java多线程并发技术
Java多线程并发技术 参考文献: http://blog.csdn.net/aboy123/article/details/38307539 http://blog.csdn.net/ghsau/a ...
- Java多线程并发02——线程的生命周期与常用方法,你都掌握了吗
在上一章,为大家介绍了线程的一些基础知识,线程的创建与终止.本期将为各位带来线程的生命周期与常用方法.关注我的公众号「Java面典」了解更多 Java 相关知识点. 线程生命周期 一个线程不是被创建了 ...
- 从火箭发场景来学习Java多线程并发闭锁对象
从火箭发场景来学习Java多线程并发闭锁对象 倒计时器场景 在我们开发过程中,有时候会使用到倒计时计数器.最简单的是:int size = 5; 执行后,size—这种方式来实现.但是在多线程并发的情 ...
- Java多线程并发编程一览笔录
线程是什么? 线程是进程中独立运行的子任务. 创建线程的方式 方式一:将类声明为 Thread 的子类.该子类应重写 Thread 类的 run 方法 方式二:声明实现 Runnable 接口的类.该 ...
- Java 多线程并发编程面试笔录一览
知识体系图: 1.线程是什么? 线程是进程中独立运行的子任务. 2.创建线程的方式 方式一:将类声明为 Thread 的子类.该子类应重写 Thread 类的 run 方法 方式二:声明实现 Runn ...
- java 多线程并发问题总结
java 多线程并发主要通过关键字synchronized实现 Java语言的关键字,当它用来修饰一个方法或者一个代码块的时候,能够保证在同一时刻最多只有一个线程执行该段代码. 一.当两个并发线程访问 ...
- Java多线程并发03——在Java中线程是如何调度的
在前两篇文章中,我们已经了解了关于线程的创建与常用方法等相关知识.接下来就来了解下,当你运行线程时,线程是如何调度的.关注我的公众号「Java面典」了解更多 Java 相关知识点. 多任务系统往往需要 ...
随机推荐
- 【算法】Tarjan算法求强连通分量
概念: 在有向图G中,如果两个定点u可以到达v,并且v也可以到达u,那么我们称这两个定点强连通. 如果有向图G的任意两个顶点都是强连通的,那么我们称G是一个强连通图. 一个有向图中的最大强连通子图,称 ...
- ASP.NET Core 3.x API版本控制
前言 一般来说需要更改我们API的时候才考虑版本控制,但是我觉得我们不应该等到那时候来实现它,我们应该有一个版本策略从我们应用程序开发时就开始制定好我们的策略,我们一直遵循着这个策略进行开发. 我们其 ...
- Java实现 LeetCode 430 扁平化多级双向链表
430. 扁平化多级双向链表 您将获得一个双向链表,除了下一个和前一个指针之外,它还有一个子指针,可能指向单独的双向链表.这些子列表可能有一个或多个自己的子项,依此类推,生成多级数据结构,如下面的示例 ...
- Java实现 蓝桥杯VIP 算法提高 勾股数
算法提高 勾股数 时间限制:1.0s 内存限制:256.0MB 问题描述 勾股数是一组三个自然数,a < b < c,以这三个数为三角形的三条边能够形成一个直角三角形 输出所有a + b ...
- Java实现 蓝桥杯VIP 算法提高 多项式输出
算法提高 多项式输出 时间限制:1.0s 内存限制:512.0MB 问题描述 一元n 次多项式可用如下的表达式表示: f(x)=a[n]xn+a[n-1]x(n-1)+-+a[1]x+a[0], a[ ...
- java实现第四届蓝桥杯黄金连分数
黄金连分数 题目描述 黄金分割数0.61803- 是个无理数,这个常数十分重要,在许多工程问题中会出现.有时需要把这个数字求得很精确. 对于某些精密工程,常数的精度很重要.也许你听说过哈勃太空望远镜, ...
- 移除VS解决方案中的TFS版本控制
项目每次会弹出提示 正在打开的解决方案已绑定到以下 Azure DevOps Server 上的源代码管理: xxxxx.是否要联系此服务器以尝试启用源代码管理集成? 移除VS解决方案中的TFS版本控 ...
- Servlet中的请求转发
请求转发时,传递到下一个servlet的request和response可能内存地址不同,但是里面包含的内容是相同的 // servlet1 RequestDispatcher dispatcher ...
- Python内置Turtle绘图库方法简介+多案例
urtle库是Python语言中一个很流行的绘制图像的函数库,想象一个小乌龟,在一个横轴为x.纵轴为y的坐标系原点,(0,0)位置开始,它根据一组函数指令的控制,在这个平面坐标系中移动,从而在它爬行的 ...
- k8s+docker部署Golang项目
Go环境搭建 root账户 下载Golang [root@infra2-test-k8s /]# cd /usr/local/ [root@infra2-test-k8s local]# wget h ...