线程池

1.接口 Executor void execute(Runnable command) 在未来某个时间执行给定的命令。 2.接口 public interface ExecutorService extends Executor submit(Runnable task) 提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future。 submit(Callable<T> task) 提交一个返回值的任务用于执行，返回一个表示任务的未决结果的 Future。 invokeAll(Collection<? extends Callable<T>> tasks) 执行给定的任务，当所有任务完成时，返回保持任务状态和结果的 Future 列表。 shutdown() 启动一次顺序关闭，执行以前提交的任务，但不接受新任务。 List<Runnable> shutdownNow() 试图停止所有正在执行的活动任务，暂停处理正在等待的任务，并返回等待执行的任务列表。 3.接口public interface ScheduledExecutorService extends ExecutorService 一个 ExecutorService，可安排在给定的延迟后运行或定期执行的命令。 4，抽象类public abstract class

1 介绍 自定义线程池，有两种实现方式： 更改spring默认的线程池配置，全局生效 自定义新的线程池，指定作用范围 上一篇文章 《Spring Boot笔记-多线程系列(一)-使用多线程》 使用的就是spring默认的线程池。 2 实现 2.1 更改spring默认线程池配置 2.1.1 介绍 创建一个类，需要实现 AsyncConfigurer 即可。 2.1.2 样例 2.1.2.1 目录结构 ├── Study │ ├── src │ │ ├── main │ │ │ ├── java │ │ │ │ └── top │ │ │ │ └── yxdz │ │ │ │ └── study │ │ │ │ └── spring │ │ │ │ └── springboot │ │ │ │ ├── thread │ │ │ │ │ └── service │ │ │ │ │ ├── ITestService.java │ │ │ │ │ └── impl │ │ │ │ │ └── TestSerivceImpl.java │ │ │ │ └── utils │ │ │ │ ├── SysThreadValueConfig.java │ │ │ │ └── config │ │ │ │ └── Thread │ │ │ │ └── SysThreadConfig.java │ │

1 //Object 定义了一个引用类型的对象用于加锁 2 static Object Lock = new Object(); 3 //定义一个int类型变量0做初始值 4 static int iCheck = 0; 5 6 public static void main(String[] args) { 7 //第一个线程 8 int a = 0; 9 //创建一个数组保存打印的数值 10 List<Integer> list = new ArrayList<>(); 11 //设置线程池大小为4 12 ExecutorService fixedThreadPool = Executors.newFixedThreadPool(4); 13 //i从0开始递增1，直到小于1000跳出循环 14 for (int i = 0; i < 1000; i++) { 15 list.add(a); 16 a++; 17 } 18 //循环触发4个任务丢给线程池处理 19 for (int i = 0; i < list.size(); i++) { 20 int z = list.get(i); 21 //把任务交给线程池 22 fixedThreadPool.execute(() -> { 23 Test(z); 24 }); 25 } 26 } 27 28 public

工具类 CountDownLatch 利用它可以实现类似计数器的功能。比如有一个任务A，它要等待其他4个任务执行完毕之后才能执行，此时就可以利用CountDownLatch来实现这种功能了。 package com.yjc.juc; import java.util.concurrent.CountDownLatch; public class CountDownLatchDemo { public static void main(String[] args) throws InterruptedException { System.out.println("主线程启动---->等待子线程执行完毕"); //代表等待两个线程执行完主线程才继续执行 CountDownLatch countDownLatch=new CountDownLatch(2); new Thread(() -> { System.out.println("第一个子线程" + Thread.currentThread().getName() + "正在执行"); countDownLatch.countDown(); System.out.println("第一个子线程" + Thread.currentThread().getName() + "执行完毕"); }).start(); new Thread(

转载: Java NIO：浅析I/O模型 一.什么是同步？什么是异步？ 　　同步和异步的概念出来已经很久了，网上有关同步和异步的说法也有很多。以下是我个人的理解： 　　同步就是：如果有多个任务或者事件要发生，这些任务或者事件必须逐个地进行，一个事件或者任务的执行会导致整个流程的暂时等待，这些事件没有办法并发地执行； 　　异步就是：如果有多个任务或者事件发生，这些事件可以并发地执行，一个事件或者任务的执行不会导致整个流程的暂时等待。 　　这就是同步和异步。举个简单的例子，假如有一个任务包括两个子任务A和B，对于同步来说，当A在执行的过程中，B只有等待，直至A执行完毕，B才能执行；而对于异步就是A和B可以并发地执行，B不必等待A执行完毕之后再执行，这样就不会由于A的执行导致整个任务的暂时等待。 　　如果还不理解，可以先看下面这2段代码： void fun1() { } void fun2() { } void function(){ fun1(); fun2() ..... ..... } 　　这段代码就是典型的同步，在方法function中，fun1在执行的过程中会导致后续的fun2无法执行，fun2必须等待fun1执行完毕才可以执行。 　　接着看下面这段代码： void fun1() { } void fun2() { } void function(){ new Thread()

使用Executors可以生成的线程池 newFixedThreadPool 创建固定大小的线程池 newSingleThreadExecutor 创建只有一个线程的线程池 newCachedThreadPool 创建一个不限线程数上限的线程池，任何提交的任务都将立即执行 newScheduledThreadPool 定时或者延迟执行的线程池 使用上面的线程池会出现两种OOM 无限制的创建线程 等待队列无线扩展 由于这两种OOM，所以一般使用线程池需要使用new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue)或者它的重载生成 其中我们需要指定 corePoolSize:核心线程数量 maixmumPoolSize:最大线程数量 keepAliveTime:线程闲置存活时间 unit:keepAliveTime单位 workQueue:等待队列 rejectedHandler:拒绝的回调函数 线程执行的流程 来源： https://www.cnblogs.com/ocean-onion/p/12518987.html

配置说明： 从Spring 3.0开始，有一个用于配置TaskExecutor和TaskScheduler实例的XML命名空间。它还提供了一种方便的方法来配置要使用触发器安排的任务。 任务调度器的配置详细参数说明： task:scheduler/@pool-size：调度线程池的大小，调度线程在被调度任务完成前不会空闲 task:scheduled/@cron：cron表达式，注意，若上次任务未完成，即使到了下一次调度时间，任务也不会重复调度 <task:scheduled-tasks scheduler="scheduler"> <task:scheduled ref="beanID" method="methodName" cron="CronExp" /> </task:scheduled-tasks> <task:scheduler id="scheduler" pool-size="10" /> 任务执行器配置详细参数说明： task:executor/@pool-size：可以指定执行线程池的初始大小、最大大小 task:executor/@queue-capacity：等待执行的任务队列的容量 task:executor/@rejection-policy：当等待队列爆了时的策略，分为丢弃、由任务执行器直接运行等方式 <task:executor id=

某厂面试归来，发现自己落伍了！>>> 作者：空无 https://segmentfault.com/a/1190000021109130 问题描述 前几天在帮同事排查生产一个线上偶发的线程池错误，逻辑很简单，线程池执行了一个带结果的异步任务。 但是最近有偶发的报错： java.util.concurrent.RejectedExecutionException: Task java.util.concurrent.FutureTask@a5acd19 rejected from java.util.concurrent.ThreadPoolExecutor@30890a38\[Terminated, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 0\] 本文中的模拟代码已经问题都是在HotSpot java8 (1.8.0_221)版本下模拟&出现的 下面是模拟代码，通过Executors.newSingleThreadExecutor创建一个单线程的线程池，然后在调用方获取Future的结果 public class ThreadPoolTest { public static void main(String\[\] args) { final ThreadPoolTest

1.BIO、NIO 和 AIO 的区别？ BIO：一个连接一个线程，客户端有连接请求时服务器端就需要启动一个线程进行处理。线 程开销大。 伪异步 IO：将请求连接放入线程池，一对多，但线程还是很宝贵的资源。 NIO：一个请求一个线程，但客户端发送的连接请求都会注册到多路复用器上，多路复用 器轮询到连接有 I/O 请求时才启动一个线程进行处理。 AIO：一个有效请求一个线程，客户端的 I/O 请求都是由 OS 先完成了再通知服务器应用去 启动线程进行处理， BIO 是面向流的，NIO 是面向缓冲区的；BIO 的各种流是阻塞的。而 NIO 是非阻塞的；BIO 的 Stream 是单向的，而 NIO 的 channel 是双向的。 NIO的特点：事件驱动模型、单线程处理多任务、非阻塞 I/O，I/O 读写不再阻塞，而是返 回 0、基于 block 的传输比基于流的传输更高效、更高级的 IO 函数 zero-copy、IO 多路复用 大大提高了 Java 网络应用的可伸缩性和实用性。基于 Reactor 线程模型。 在 Reactor 模式中，事件分发器等待某个事件或者可应用或个操作的状态发生，事件分发 器就把这个事件传给事先注册的事件处理函数或者回调函数，由后者来做实际的读写操 作。如在 Reactor 中实现读：注册读就绪事件和相应的事件处理器、事件分发器等待事 件、事件到来

1 import time 2 from concurrent.futures import ThreadPoolExecutor 3 4 def RunBenchmark(url): 5 print('GET %s' % url) 6 response = url 7 time.sleep(3) 8 return(url+" FINISHED") 9 10 def RunPool(): 11 urls = 'CPU' 12 pool = ThreadPoolExecutor(1)　　　　　　　　　 #启动一个线程池 13 task=pool.submit(RunBenchmark, urls)　　　　　#在另外的线程中运行RunBenchmark()　 14 while(not task.done()):　　　　　　　　　　　　　#task.done()表示线程池中的工作完成了 15 print("ooo")　　　　　　　　　　　　　　　　　#主线程中可以执行其他工作 16 time.sleep(0.5) 17 print("bye") 18 19 if __name__ == '__main__': 20 RunPool() https://www.jianshu.com/p/b9b3d66aa0be https://blog.csdn.net/sinat_34461756