异步线程编程，线程池，线程组，后面涉及ThreadLocal在理解
join模拟订单
package com.future.demo.future; /**
*
*
* @author Administrator
*
*/
public class NormalThreadTest { public static void main(String[] args) throws Exception {
long start = System.currentTimeMillis();
// 开启购买厨具线程
ShoppingThread shopping = new ShoppingThread();
shopping.start();
shopping.join(); // 保障厨具购买并送货
// 获取到购买厨具
KitchenWare kc = shopping.kc; // 买食材
FoodMaterial fm = new FoodMaterial();
Thread.sleep(2000);
System.out.println("第二步: 食材已经到位");
// 烹饪美食
cooking(kc, fm);
System.out.println("第三步: 美食烹饪完成");
long end = System.currentTimeMillis();
System.out.println("烹饪美食时间为:" + (end - start));
} /**
* 定义网上购物厨具线程
* @author Administrator
*
*/
static class ShoppingThread extends Thread { // 厨具对象引用
private KitchenWare kc; @Override
public void run() {
System.out.println("第一步: 网上下单");
System.out.println("第一步: 等待厨具");
try {
Thread.sleep(5000); // 等待厨具时间
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("第一步: 快递送货");
// 生产厨具
kc = new KitchenWare();
}
} /**
* 厨具类
* @author Administrator
*
*/
static class KitchenWare { } /**
* 食材类
* @author Administrator
*
*/
static class FoodMaterial { } /**
* 定义烹饪食物的方法
* @param kc
* @param fm
*/
static void cooking(KitchenWare kc, FoodMaterial fm) { }
}
异步进行
package com.future.demo.future; import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask; /**
* 异步: 同时进行
* 同步: 排队进行
* @author Administrator
*
*/
public class FutureThreadTest { public static void main(String[] args) throws Exception {
long start = System.currentTimeMillis(); Callable<KitchenWare> callable = new Callable<KitchenWare>() {
public KitchenWare call() throws Exception {
System.out.println("第一步: 网上下单");
System.out.println("第一步: 等待厨具");
try {
Thread.sleep(5000); // 等待厨具时间
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("第一步: 快递送货");
return new KitchenWare();
} };
// 包装为异步执行的对象
FutureTask<KitchenWare> task = new FutureTask<>(callable);
new Thread(task).start(); // 买食材
FoodMaterial fm = new FoodMaterial();
Thread.sleep(2000);
System.out.println("第二步: 食材已经到位"); if (!task.isDone()) {
System.out.println("厨具还没有到.....");
}
// 通过阻塞形式获取到异步块执行的结果
KitchenWare kc = task.get(); // 阻塞
// 烹饪美食
cooking(kc, fm);
System.out.println("第三步: 美食烹饪完成");
long end = System.currentTimeMillis();
System.out.println("烹饪美食时间为:" + (end - start));
} /**
* 厨具类
* @author Administrator
*
*/
static class KitchenWare { } /**
* 食材类
* @author Administrator
*
*/
static class FoodMaterial { } /**
* 定义烹饪食物的方法
* @param kc
* @param fm
*/
static void cooking(KitchenWare kc, FoodMaterial fm) { }
}
线程池
ThreadPoolExecutor
package com.future.demo.threadPool; import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit; /**
* ThreadPoolExecutor
* int corePoolSize 线程总数 <= 最大线程数
* int maximumPoolSize 最大线程数
* long keepAliveTime 存活时间
* TimeUnit unit 时间单位 (纳秒，毫秒，秒，分钟,....)
* BlockingQueue<Runnable> workQueue 阻塞队列
* @author Administrator
*
*/
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
// 20来源: 最大线程数 + 阻塞数目
ThreadPoolExecutor executor =
new ThreadPoolExecutor(10, 30, 2000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(10)); for ( int i = 0; i < 40; i++) {
executor.execute(new MyRunnable());
System.out.println("线程池中线程数目：" + executor.getPoolSize() + "，队列中等待执行的任务数目：" + executor.getQueue().size()
+ "，任务总数目：" + executor.getTaskCount());
} // 防止线程溢出(执行完成的线程会被及时关闭)
executor.shutdownNow();
} static class MyRunnable implements Runnable {
public void run() {
String threadName = Thread.currentThread().getName();
System.out.println(threadName+ "准备执行......");
/*try {
// jdk1.5 之后官方推荐使用此方法睡眠
TimeUnit.MILLISECONDS.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}*/
System.out.println(threadName+"执行完成......"); }
}
}
SingleThreadExecutor
package com.future.demo.threadPool; import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* 创建一个单线程的线程池。这个线程池只有一个线程在工作，
* 也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，
* 那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。
* @author Administrator
*
*/
public class SingleThreadExecutorTest { public static void main(String[] args) {
MyThread t1 = new MyThread("AAA");
MyThread t2 = new MyThread("BBB");
MyThread t3 = new MyThread("CCC");
MyThread t4 = new MyThread("DDD"); ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
// 保证在线程池中的线程执行的顺序
singleThreadExecutor.execute(t4);
singleThreadExecutor.execute(t1);
singleThreadExecutor.execute(t2);
singleThreadExecutor.execute(t3); singleThreadExecutor.shutdown();
} } class MyThread extends Thread {
private String name;
public MyThread(String name) {
super(name);
this.name = name;
} @Override
public void run() {
System.out.println(name+"执行");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
FixedThreadExecutor
package com.future.demo.threadPool; import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* 创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。
* 线程池的大小一旦达到最大值就会保持不变，
* 如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。
* @author Administrator
*
*/
public class FixedThreadExecutorTest { public static void main(String[] args) {
MyThread t1 = new MyThread("AAA");
MyThread t2 = new MyThread("BBB");
MyThread t3 = new MyThread("CCC");
MyThread t4 = new MyThread("DDD"); ExecutorService singleThreadExecutor = Executors.newFixedThreadPool(2); singleThreadExecutor.execute(t1);
singleThreadExecutor.execute(t2);
singleThreadExecutor.execute(t3);
singleThreadExecutor.execute(t4); singleThreadExecutor.shutdown();
} }
CacheThreadExecutor
package com.future.demo.threadPool; import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* 创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，
那么就会回收部分空闲（60秒不执行任务）的线程，
当任务数增加时，此线程池又可以智能的添加新线程来处理任务。
此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小
* @author Administrator
*
*/
public class CacheThreadExecutorTest { public static void main(String[] args) {
MyThread t1 = new MyThread("AAA");
MyThread t2 = new MyThread("BBB");
MyThread t3 = new MyThread("CCC");
MyThread t4 = new MyThread("DDD"); ExecutorService singleThreadExecutor = Executors.newCachedThreadPool(); singleThreadExecutor.execute(t1);
singleThreadExecutor.execute(t2);
singleThreadExecutor.execute(t3);
singleThreadExecutor.execute(t4); singleThreadExecutor.shutdown();
} }
ScheduledThreadExecutor
package com.future.demo.threadPool; import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit; /***
* 创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。
* @author Administrator
*
*/
public class ScheduledThreadExecutorTest {
public static void main(String[] args) {
ScheduledThreadPoolExecutor exec = new ScheduledThreadPoolExecutor(2); exec.scheduleAtFixedRate(new Runnable() {// 每隔一段时间就触发异常 @Override
public void run() { System.out.println("================"); } }, 1, 1, TimeUnit.SECONDS); exec.scheduleAtFixedRate(new Runnable() {// 每隔一段时间打印系统时间，证明两者是互不影响的 public void run() { System.out.println(System.nanoTime()); } }, 1, 100, TimeUnit.MILLISECONDS); }
}
线程组
ThreadGroup
package com.future.demo.threadgroup;
public class ThreadGroupTest {
public static void main(String[] args) throws Exception {
ThreadGroup group = new ThreadGroup("main Thread");
Thread t1 = new Thread(group,"AAA") {
@Override
public void run() {
while(true) {
System.out.println(Thread.currentThread().getName()+"执行");
}
}
};
Thread t2 = new Thread(group,"BBB") {
@Override
public void run() {
while(true) {
System.out.println(Thread.currentThread().getName()+"执行");
}
}
};
t1.start();
t2.start();
Thread.sleep(5000);
System.out.println(Thread.currentThread().getThreadGroup().activeCount());
group.list();
}
}
package com.future.demo.conn; import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReentrantLock; public class NormalConnectionPool {
private Map<String, Connection> connPool = new HashMap<String, Connection>();
private ReentrantLock lock = new ReentrantLock(); public Connection getConnection(String key) { Connection conn = null; try {
lock.lock(); if (connPool.containsKey(key)) {
conn = connPool.get(key);
} else {
// 创建连接对象
conn = crateConn();
connPool.put(key, conn);
} } catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
} return conn;
} private Connection crateConn() {
return new Connection();
} public static void main(String[] args) throws Exception {
NormalConnectionPool pool = new NormalConnectionPool();
long start = System.currentTimeMillis(); Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 200000; i++) {
Connection conn = pool.getConnection("KK");
System.out.println("KK-----"+conn);
}
}
}); Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 200000; i++) {
Connection conn = pool.getConnection("YY");
System.out.println("YY-----"+conn);
}
}
}); Thread t3 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 200000; i++) {
Connection conn = pool.getConnection("FF");
System.out.println("FF-----"+conn);
}
}
}); t1.start();t2.start();t3.start();
t1.join();t2.join();t3.join(); long end = System.currentTimeMillis();
System.out.println(end - start);
}
} class Connection { }
package com.future.demo.conn; import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask; public class SuperConnectionPool { private ConcurrentHashMap<String, FutureTask<Connection>> connPool = new ConcurrentHashMap<>(); public Connection getConnection(String key) {
Connection conn = null;
FutureTask<Connection> connectionTask = connPool.get(key); if (connectionTask != null) {
try {
conn = connectionTask.get();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
} else {
Callable<Connection> callable = new Callable<Connection>() { @Override
public Connection call() throws Exception {
return new Connection();
} };
FutureTask<Connection> newTask = new FutureTask<>(callable);
connPool.putIfAbsent(key, newTask);
if (connectionTask == null) {
connectionTask = newTask;
connectionTask.run();
}
} try {
conn = connectionTask.get();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
} return conn;
} public static void main(String[] args) throws InterruptedException {
SuperConnectionPool pool = new SuperConnectionPool();
long start = System.currentTimeMillis(); Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 200000; i++) {
Connection conn = pool.getConnection("KK");
System.out.println("KK-----"+conn);
}
}
}); Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 200000; i++) {
Connection conn = pool.getConnection("YY");
System.out.println("YY-----"+conn);
}
}
}); Thread t3 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 200000; i++) {
Connection conn = pool.getConnection("FF");
System.out.println("FF-----"+conn);
}
}
}); t1.start();t2.start();t3.start();
t1.join();t2.join();t3.join(); long end = System.currentTimeMillis();
System.out.println(end - start);
}
}
异步线程编程，线程池，线程组，后面涉及ThreadLocal在理解的更多相关文章
- 并发编程---线程queue---进程池线程池---异部调用(回调机制)
线程 队列:先进先出 堆栈:后进先出 优先级:数字越小优先级越大,越先输出 import queue q = queue.Queue(3) # 先进先出-->队列 q.put('first') ...
- python并发编程-进程池线程池-协程-I/O模型-04
目录 进程池线程池的使用***** 进程池/线程池的创建和提交回调 验证复用池子里的线程或进程 异步回调机制 通过闭包给回调函数添加额外参数(扩展) 协程*** 概念回顾(协程这里再理一下) 如何实现 ...
- Posix线程编程指南(4) 线程终止
线程终止方式 一般来说,Posix的线程终止有两种情况:正常终止和非正常终止.线程主动调用pthread_exit()或者从线程函数中return都将使线程正常退出,这是可预见的退出方式:非正常终止是 ...
- Posix线程编程指南(2) 线程私有数据
概念及作用 在单线程程序中,我们经常要用到"全局变量"以实现多个函数间共享数据.在多线程环境下,由于数据空间是共享的,因此全局变量也为所有线程所共有.但有时应用程序设计中有必要提供 ...
- Posix线程编程指南(1) 线程创建与取消
线程创建 1．1 线程与进程 相对进程而言,线程是一个更加接近于执行体的概念,它可以与同进程中的其他线程共享数据,但拥有自己的栈空间,拥有独立的执行序列.在串行程序基础上引入线程和进程是为了提高程序的 ...
- Linux 线程编程2.0——线程同步-互斥锁
当我们需要控制对共享资源的存取的时候,可以用一种简单的加锁的方法来控制.我们可以创建一个读/写程序,它们共用一个共享缓冲区,使用互斥锁来控制对缓冲区的存取. 函数 pthread_mutex_init ...
- (并发编程)进程池线程池--提交任务2种方式+（异步回调)、协程--yield关键字 greenlet ,gevent模块
一:进程池与线程池(同步,异步+回调函数)先造个池子,然后放任务为什么要用“池”:池子使用来限制并发的任务数目,限制我们的计算机在一个自己可承受的范围内去并发地执行任务池子内什么时候装进程:并发的任务 ...
- Posix线程编程指南(3) 线程同步
互斥锁 尽管在Posix Thread中同样可以使用IPC的信号量机制来实现互斥锁mutex功能,但显然semphore的功能过于强大了,在Posix Thread中定义了另外一套专门用于线程同步的m ...
- Posix线程编程指南
Posix线程编程指南 Posix线程编程指南... 1 一线程创建与取消... 2 线程创建... 2 1．线程与进程... 2 2. 创建线程... 2 3. 线程创建属性... 2 4. 创建的 ...
随机推荐
- <错误>
1. package com.multak.cookaraclient.adapter; import android.content.Context; import android.support. ...
- 我的nginx+php是如何配置的？
nginx使用homebrew安装,安装之后 ngxin 安装目录:/usr/local/Cellar/nginx/1.8.0 删除掉默认的www目录,创建一个自己方便找到的 删除掉默认的www目录 ...
- day06-2 基本运算符（解压缩）
目录 运算符 算数运算符 比较运算符 赋值运算符 逻辑运算符 运算规则 成员运算符 身份运算符 Python运算符优先级 链式赋值(必考) 交叉赋值(必考) 解压缩(必考) 运算符 算数运算符 进行算 ...
- 全文检索lucene6.1的检索方式
背景: 工作任务完成后,闲暇之计给自己充充电! Lucene是一个纯java全文检索工具包,采用倒排索引原理. 全文检索:指的是计算机索引程序通过扫描文章的每一个词,对每一个词建立一个索引,并指明该词 ...
- 转：用java调用oracle存储过程总结（比较好理解）
这段时间开始学习写存储过程,主要原因还是因为工作需要吧,本来以为很简单的,但几经挫折,豪气消磨殆尽,但总算搞通了,为了避免后来者少走弯路,特记述与此,同时亦对自己进行鼓励. 一:无返回值的存储过程 存 ...
- [读书笔记] R语言实战 （六） 基本图形方法
1. 条形图 barplot() #载入vcd包 library(vcd) #table函数提取各个维度计数 counts <- table(Arthritis$Improved) count ...
- keepalived 和 heartbeat对比
Keepalived使用的vrrp协议方式,虚拟路由冗余协议 (Virtual Router Redundancy Protocol,简称VRRP): Heartbeat是基于主机或网络的服务的高可用 ...
- 《你又怎么了我错了行了吧》【Beta】Scrum Meeting 2
第二天 日期:2019/6/25 前言: 第2次会议在女生宿舍召开 确认编码阶段已经完成,继续测试项目 1.1 今日完成任务情况以及明日任务安排 姓名 当前阶段任务 下一阶段任务 刘 佳 完善了未开发 ...
- centos7下部署FastDFS分布式文件系统
前言 项目中用到文件服务器,有朋友推荐用FastDFS,所以就了解学习了一番,感觉确实颇为强大,在此再次感谢淘宝资深架构师余庆大神开源了如此优秀的轻量级分布式文件系统,本篇文章就记录一下FastDFS ...
- STM32 IIC双机通信—— HAL库硬件IIC版
参考传送门 关于IIC的原理这里我就不多说了,网上有很多很好的解析,如果要看我个人对IIC的理解的话,可以点击查看,这里主要讲一下怎样利用STM32CubeMx实现IIC的通讯,经过个人实践,感觉HA ...