网易云课堂微专业--Java高级开发工程师--多线程并发编程--学习笔记(一)
2019-03-11 20:02
2386 查看
文章目录
第一章 多线程并发编程
第一节 Java基础
1.1.1 Java程序运行原理分析
class文件内容
JVM运行时数据区
方法区
堆内存
虚拟机栈
本地方法栈
程序计数器
查看class文件内容
- class内容-版本号/访问控制
- class内容–常量池
- class内容–构造方法
- class内容–程序入口main方法
JVM指令码表下载链接: https://pan.baidu.com/s/1T0h8GgP25vvFRmGx98KtfA 提取码: 92ag
程序完整运行分析
-
加载信息到方法区
-
JVM创建线程来执行代码
1.1.2 线程状态
多线程运行状态切换源码示例
package com.study.hc.thread.chapter1.thread; /** * 示例2 - 多线程运行状态切换示例 <br/> */ public class Demo2 { public static Thread thread1; public static Demo2 obj; public static void main(String[] args) throws Exception { // 第一种状态切换 - 新建 -> 运行 -> 终止 System.out.println("#######第一种状态切换 - 新建 -> 运行 -> 终止################################"); Thread thread1 = new Thread(new Runnable() { @Override public void run() { System.out.println("thread1当前状态:" + Thread.currentThread().getState().toString()); System.out.println("thread1 执行了"); } }); System.out.println("没调用start方法,thread1当前状态:" + thread1.getState().toString()); thread1.start(); Thread.sleep(2000L); // 等待thread1执行结束,再看状态 System.out.println("等待两秒,再看thread1当前状态:" + thread1.getState().toString()); // thread1.start(); TODO 注意,线程终止之后,再进行调用,会抛出IllegalThreadStateException异常 System.out.println(); System.out.println("############第二种:新建 -> 运行 -> 等待 -> 运行 -> 终止(sleep方式)###########################"); Thread thread2 = new Thread(new Runnable() { @Override public void run() { try {// 将线程2移动到等待状态,1500后自动唤醒 Thread.sleep(1500); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("thread2当前状态:" + Thread.currentThread().getState().toString()); System.out.println("thread2 执行了"); } }); System.out.println("没调用start方法,thread2当前状态:" + thread2.getState().toString()); thread2.start(); System.out.println("调用start方法,thread2当前状态:" + thread2.getState().toString()); Thread.sleep(200L); // 等待200毫秒,再看状态 System.out.println("等待200毫秒,再看thread2当前状态:" + thread2.getState().toString()); Thread.sleep(3000L); // 再等待3秒,让thread2执行完毕,再看状态 System.out.println("等待3秒,再看thread2当前状态:" + thread2.getState().toString()); System.out.println(); System.out.println("############第三种:新建 -> 运行 -> 阻塞 -> 运行 -> 终止###########################"); Thread thread3 = new Thread(new Runnable() { @Override public void run() { synchronized (Demo2.class) { System.out.println("thread3当前状态:" + Thread.currentThread().getState().toString()); System.out.println("thread3 执行了"); } } }); synchronized (Demo2.class) { System.out.println("没调用start方法,thread3当前状态:" + thread3.getState().toString()); thread3.start(); System.out.println("调用start方法,thread3当前状态:" + thread3.getState().toString()); Thread.sleep(200L); // 等待200毫秒,再看状态 System.out.println("等待200毫秒,再看thread3当前状态:" + thread3.getState().toString()); } Thread.sleep(3000L); // 再等待3秒,让thread3执行完毕,再看状态 System.out.println("等待3秒,让thread3抢到锁,再看thread3当前状态:" + thread3.getState().toString()); } }
执行结果
1.1.3 线程终止
不正确的线程终止-Stop
源码示例
package com.study.hc.thread.chapter1.thread; /** * 示例3 - 线程stop强制性中止,破坏线程安全的示例 */ public class Demo3 { public static void main(String[] args) throws InterruptedException { StopThread thread = new StopThread(); thread.start(); // 休眠1秒,确保i变量自增成功 Thread.sleep(1000); // 暂停线程 // thread.stop(); // 错误的终止 thread.interrupt(); // 正确终止 while (thread.isAlive()) { // 确保线程已经终止 } // 输出结果 thread.print(); } }
package com.study.hc.thread.chapter1.thread; public class StopThread extends Thread { private int i = 0, j = 0; @Override public void run() { synchronized (this) { // 增加同步锁,确保线程安全 ++i; try { // 休眠10秒,模拟耗时操作 Thread.sleep(10000); } catch (InterruptedException e) { e.printStackTrace(); } ++j; } } /** * 打印i和j */ public void print() { System.out.println("i=" + i + " j=" + j); } }
正确的线程终止–interrupt
源码示例
正确的线程终止–标志位
package com.study.hc.thread.chapter1.thread; /** 通过状态位来判断 */ public class Demo4 extends Thread { public volatile static boolean flag = true; public static void main(String[] args) throws InterruptedException { new Thread(() -> { try { while (flag) { // 判断是否运行 System.out.println("运行中"); Thread.sleep(1000L); } } catch (InterruptedException e) { e.printStackTrace(); } }).start(); // 3秒之后,将状态标志改为False,代表不继续运行 Thread.sleep(3000L); flag = false; System.out.println("程序运行结束"); } }
1.1.4 内存屏障和CPU缓存
CPU性能优化手段–缓存
多级缓存
缓存同步协议
CPU性能优化手段–运行时指令重排
CPU性能优化存在的问题
解决办法–内存屏障
1.1.5 线程通信
通信的方式
1. 文件共享
2. 网络共享
暂略。
3. 共享变量
4.jdk提供的线程协调API
- suspend和resume死锁示例(Demo6)
package com.study.hc.thread.chapter1.thread; import java.util.concurrent.locks.LockSupport; /** 三种线程协作通信的方式:suspend/resume、wait/notify、park/unpark */ public class Demo6 { /** 包子店 */ public static Object baozidian = null; /** 正常的suspend/resume */ public void suspendResumeTest() throws Exception { // 启动线程 Thread consumerThread = new Thread(() -> { if (baozidian == null) { // 如果没包子,则进入等待 System.out.println("1、进入等待"); Thread.currentThread().suspend(); } System.out.println("2、买到包子,回家"); }); consumerThread.start(); // 3秒之后,生产一个包子 Thread.sleep(3000L); baozidian = new Object(); consumerThread.resume(); System.out.println("3、通知消费者"); } /** 死锁的suspend/resume。 suspend并不会像wait一样释放锁,故此容易写出死锁代码 */ public void suspendResumeDeadLockTest() throws Exception { // 启动线程 Thread consumerThread = new Thread(() -> { if (baozidian == null) { // 如果没包子,则进入等待 System.out.println("1、进入等待"); // 当前线程拿到锁,然后挂起 synchronized (this) { Thread.currentThread().suspend(); } } System.out.println("2、买到包子,回家"); }); consumerThread.start(); // 3秒之后,生产一个包子 Thread.sleep(3000L); baozidian = new Object(); // 争取到锁以后,再恢复consumerThread synchronized (this) { consumerThread.resume(); } System.out.println("3、通知消费者"); } /** 导致程序永久挂起的suspend/resume */ public void suspendResumeDeadLockTest2() throws Exception { // 启动线程 Thread consumerThread = new Thread(() -> { if (baozidian == null) { System.out.println("1、没包子,进入等待"); try { // 为这个线程加上一点延时 Thread.sleep(5000L); } catch (InterruptedException e) { e.printStackTrace(); } // 这里的挂起执行在resume后面 Thread.currentThread().suspend(); } System.out.println("2、买到包子,回家"); }); consumerThread.start(); // 3秒之后,生产一个包子 Thread.sleep(3000L); baozidian = new Object(); consumerThread.resume(); System.out.println("3、通知消费者"); consumerThread.join(); } /** 正常的wait/notify */ public void waitNotifyTest() throws Exception { // 启动线程 new Thread(() -> { synchronized (this) { while (baozidian == null) { // 如果没包子,则进入等待 try { System.out.println("1、进入等待"); this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } System.out.println("2、买到包子,回家"); }).start(); // 3秒之后,生产一个包子 Thread.sleep(3000L); baozidian = new Object(); synchronized (this) { this.notifyAll(); System.out.println("3、通知消费者"); } } /** 会导致程序永久等待的wait/notify */ public void waitNotifyDeadLockTest() throws Exception { // 启动线程 new Thread(() -> { if (baozidian == null) { // 如果没包子,则进入等待 try { Thread.sleep(5000L); } catch (InterruptedException e1) { e1.printStackTrace(); } synchronized (this) { try { System.out.println("1、进入等待"); this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } System.out.println("2、买到包子,回家"); }).start(); // 3秒之后,生产一个包子 Thread.sleep(3000L); baozidian = new Object(); synchronized (this) { this.notifyAll(); System.out.println("3、通知消费者"); } } /** 正常的park/unpark */ public void parkUnparkTest() throws Exception { // 启动线程 Thread consumerThread = new Thread(() -> { while (baozidian == null) { // 如果没包子,则进入等待 System.out.println("1、进入等待"); LockSupport.park(); } System.out.println("2、买到包子,回家"); }); consumerThread.start(); // 3秒之后,生产一个包子 Thread.sleep(3000L); baozidian = new Object(); LockSupport.unpark(consumerThread); System.out.println("3、通知消费者"); } /** 死锁的park/unpark */ public void parkUnparkDeadLockTest() throws Exception { // 启动线程 Thread consumerThread = new Thread(() -> { if (baozidian == null) { // 如果没包子,则进入等待 System.out.println("1、进入等待"); // 当前线程拿到锁,然后挂起 synchronized (this) { LockSupport.park(); } } System.out.println("2、买到包子,回家"); }); consumerThread.start(); // 3秒之后,生产一个包子 Thread.sleep(3000L); baozidian = new Object(); // 争取到锁以后,再恢复consumerThread synchronized (this) { LockSupport.unpark(consumerThread); } System.out.println("3、通知消费者"); } public static void main(String[] args) throws Exception { // 对调用顺序有要求,也要开发自己注意锁的释放。这个被弃用的API, 容易死锁,也容易导致永久挂起。 // new Demo6().suspendResumeTest(); // new Demo6().suspendResumeDeadLockTest(); // new Demo6().suspendResumeDeadLockTest2(); // wait/notify要求再同步关键字里面使用,免去了死锁的困扰,但是一定要先调用wait,再调用notify,否则永久等待了 // new Demo6().waitNotifyTest(); // new Demo6().waitNotifyDeadLockTest(); // park/unpark没有顺序要求,但是park并不会释放锁,所有再同步代码中使用要注意 // new Demo6().parkUnparkTest(); new Demo6().parkUnparkDeadLockTest(); } }
- wait/notify机制
park/unpark机制(Demo6里)
- park/unpark机制代码示例
伪唤醒
1.1.6 线程封闭之ThreadLocal和栈封闭
线程封闭概念
ThreadLocal
package com.study.hc.thread.chapter1.thread; /** 线程封闭示例 */ public class Demo7 { /** threadLocal变量,每个线程都有一个副本,互不干扰 */ public static ThreadLocal<String> value = new ThreadLocal<>(); /** * threadlocal测试 * * @throws Exception */ public void threadLocalTest() throws Exception { // threadlocal线程封闭示例 value.set("这是主线程设置的123"); // 主线程设置值 String v = value.get(); System.out.println("线程1执行之前,主线程取到的值:" + v); new Thread(new Runnable() { @Override public void run() { String v = value.get(); System.out.println("线程1取到的值:" + v); // 设置 threadLocal value.set("这是线程1设置的456"); v = value.get(); System.out.println("重新设置之后,线程1取到的值:" + v); System.out.println("线程1执行结束"); } }).start(); Thread.sleep(5000L); // 等待所有线程执行结束 v = value.get(); System.out.println("线程1执行之后,主线程取到的值:" + v); } public static void main(String[] args) throws Exception { new Demo7().threadLocalTest(); } }
栈封闭
1.1.7 线程池应用及实现原理剖析
为什么要用线程池?
线程池原理–概念
线程池API–接口定义和实现类
线程池API–方法定义
ExcutorService
ScheduleExecutorService
实例代码Demo9
package com.study.hc.thread.chapter1.thread; import java.util.Collections; import java.util.List; import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.RejectedExecutionHandler; import java.util.concurrent.ScheduledThreadPoolExecutor; import java.util.concurrent.SynchronousQueue; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; /** 线程池的使用 */ public class Demo9 { /** * 测试: 提交15个执行时间需要3秒的任务,看线程池的状况 * * @param threadPoolExecutor 传入不同的线程池,看不同的结果 * @throws Exception */ public void testCommon(ThreadPoolExecutor threadPoolExecutor) throws Exception { // 测试: 提交15个执行时间需要3秒的任务,看超过大小的2个,对应的处理情况 for (int i = 0; i < 15; i++) { int n = i; threadPoolExecutor.submit(new Runnable() { @Override public void run() { try { System.out.println("开始执行:" + n); Thread.sleep(3000L); System.err.println("执行结束:" + n); } catch (InterruptedException e) { e.printStackTrace(); } } }); System.out.println("任务提交成功 :" + i); } // 查看线程数量,查看队列等待数量 Thread.sleep(500L); System.out.println("当前线程池线程数量为:" + threadPoolExecutor.getPoolSize()); System.out.println("当前线程池等待的数量为:" + threadPoolExecutor.getQueue().size()); // 等待15秒,查看线程数量和队列数量(理论上,会被超出核心线程数量的线程自动销毁) Thread.sleep(15000L); System.out.println("当前线程池线程数量为:" + threadPoolExecutor.getPoolSize()); System.out.println("当前线程池等待的数量为:" + threadPoolExecutor.getQueue().size()); } /** * 1、线程池信息: 核心线程数量5,最大数量10,无界队列,超出核心线程数量的线程存活时间:5秒, 指定拒绝策略的 * * @throws Exception */ private void threadPoolExecutorTest1() throws Exception { ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>()); testCommon(threadPoolExecutor); // 预计结果:线程池线程数量为:5,超出数量的任务,其他的进入队列中等待被执行 } /** * 2、 线程池信息: 核心线程数量5,最大数量10,队列大小3,超出核心线程数量的线程存活时间:5秒, 指定拒绝策略的 * * @throws Exception */ private void threadPoolExecutorTest2() throws Exception { // 创建一个 核心线程数量为5,最大数量为10,等待队列最大是3 的线程池,也就是最大容纳13个任务。 // 默认的策略是抛出RejectedExecutionException异常,java.util.concurrent.ThreadPoolExecutor.AbortPolicy ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(3), new RejectedExecutionHandler() { @Override public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) { System.err.println("有任务被拒绝执行了"); } }); testCommon(threadPoolExecutor); // 预计结果: // 1、 5个任务直接分配线程开始执行 // 2、 3个任务进入等待队列 // 3、 队列不够用,临时加开5个线程来执行任务(5秒没活干就销毁) // 4、 队列和线程池都满了,剩下2个任务,没资源了,被拒绝执行。 // 5、 任务执行,5秒后,如果无任务可执行,销毁临时创建的5个线程 } /** * 3、 线程池信息: 核心线程数量5,最大数量5,无界队列,超出核心线程数量的线程存活时间:5秒 * * @throws Exception */ private void threadPoolExecutorTest3() throws Exception { // 和Executors.newFixedThreadPool(int nThreads)一样的 ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 5, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()); testCommon(threadPoolExecutor); // 预计结:线程池线程数量为:5,超出数量的任务,其他的进入队列中等待被执行 } /** * 4、 线程池信息: * 核心线程数量0,最大数量Integer.MAX_VALUE,SynchronousQueue队列,超出核心线程数量的线程存活时间:60秒 * * @throws Exception */ private void threadPoolExecutorTest4() throws Exception { // SynchronousQueue,实际上它不是一个真正的队列,因为它不会为队列中元素维护存储空间。与其他队列不同的是,它维护一组线程,这些线程在等待着把元素加入或移出队列。 // 在使用SynchronousQueue作为工作队列的前提下,客户端代码向线程池提交任务时, // 而线程池中又没有空闲的线程能够从SynchronousQueue队列实例中取一个任务, // 那么相应的offer方法调用就会失败(即任务没有被存入工作队列)。 // 此时,ThreadPoolExecutor会新建一个新的工作者线程用于对这个入队列失败的任务进行处理(假设此时线程池的大小还未达到其最大线程池大小maximumPoolSize)。 // 和Executors.newCachedThreadPool()一样的 ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>()); testCommon(threadPoolExecutor); // 预计结果: // 1、 线程池线程数量为:15,超出数量的任务,其他的进入队列中等待被执行 // 2、 所有任务执行结束,60秒后,如果无任务可执行,所有线程全部被销毁,池的大小恢复为0 Thread.sleep(60000L); System.out.println("60秒后,再看线程池中的数量:" + threadPoolExecutor.getPoolSize()); } /** * 5、 定时执行线程池信息:3秒后执行,一次性任务,到点就执行 <br/> * 核心线程数量5,最大数量Integer.MAX_VALUE,DelayedWorkQueue延时队列,超出核心线程数量的线程存活时间:0秒 * * @throws Exception */ private void threadPoolExecutorTest5() throws Exception { // 和Executors.newScheduledThreadPool()一样的 ScheduledThreadPoolExecutor threadPoolExecutor = new ScheduledThreadPoolExecutor(5); threadPoolExecutor.schedule(new Runnable() { @Override public void run() { System.out.println("任务被执行,现在时间:" + System.currentTimeMillis()); } }, 3000, TimeUnit.MILLISECONDS); System.out.println( "定时任务,提交成功,时间是:" + System.currentTimeMillis() + ", 当前线程池中线程数量:" + threadPoolExecutor.getPoolSize()); // 预计结果:任务在3秒后被执行一次 } /** * 6、 定时执行线程池信息:线程固定数量5 ,<br/> * 核心线程数量5,最大数量Integer.MAX_VALUE,DelayedWorkQueue延时队列,超出核心线程数量的线程存活时间:0秒 * * @throws Exception */ private void threadPoolExecutorTest6() throws Exception { ScheduledThreadPoolExecutor threadPoolExecutor = new ScheduledThreadPoolExecutor(5); // 周期性执行某一个任务,线程池提供了两种调度方式,这里单独演示一下。测试场景一样。 // 测试场景:提交的任务需要3秒才能执行完毕。看两种不同调度方式的区别 // 效果1: 提交后,2秒后开始第一次执行,之后每间隔1秒,固定执行一次(如果发现上次执行还未完毕,则等待完毕,完毕后立刻执行)。 // 也就是说这个代码中是,3秒钟执行一次(计算方式:每次执行三秒,间隔时间1秒,执行结束后马上开始下一次执行,无需等待) threadPoolExecutor.scheduleAtFixedRate(new Runnable() { @Override public void run() { try { Thread.sleep(3000L); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("任务-1 被执行,现在时间:" + System.currentTimeMillis()); } }, 2000, 1000, TimeUnit.MILLISECONDS); // 效果2:提交后,2秒后开始第一次执行,之后每间隔1秒,固定执行一次(如果发现上次执行还未完毕,则等待完毕,等上一次执行完毕后再开始计时,等待1秒)。 // 也就是说这个代码钟的效果看到的是:4秒执行一次。 (计算方式:每次执行3秒,间隔时间1秒,执行完以后再等待1秒,所以是 3+1) threadPoolExecutor.scheduleWithFixedDelay(new Runnable() { @Override public void run() { try { Thread.sleep(3000L); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("任务-2 被执行,现在时间:" + System.currentTimeMillis()); } }, 2000, 1000, TimeUnit.MILLISECONDS); } /** * 7、 终止线程:线程池信息: 核心线程数量5,最大数量10,队列大小3,超出核心线程数量的线程存活时间:5秒, 指定拒绝策略的 * * @throws Exception */ private void threadPoolExecutorTest7() throws Exception { // 创建一个 核心线程数量为5,最大数量为10,等待队列最大是3 的线程池,也就是最大容纳13个任务。 // 默认的策略是抛出RejectedExecutionException异常,java.util.concurrent.ThreadPoolExecutor.AbortPolicy ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(3), new RejectedExecutionHandler() { @Override public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) { System.err.println("有任务被拒绝执行了"); } }); // 测试: 提交15个执行时间需要3秒的任务,看超过大小的2个,对应的处理情况 for (int i = 0; i < 15; i++) { int n = i; threadPoolExecutor.submit(new Runnable() { @Override public void run() { try { System.out.println("开始执行:" + n); Thread.sleep(3000L); System.err.println("执行结束:" + n); } catch (InterruptedException e) { System.out.println("异常:" + e.getMessage()); } } }); System.out.println("任务提交成功 :" + i); } // 1秒后终止线程池 Thread.sleep(1000L); threadPoolExecutor.shutdown(); // 再次提交提示失败 threadPoolExecutor.submit(new Runnable() { @Override public void run() { System.out.println("追加一个任务"); } }); // 结果分析 // 1、 10个任务被执行,3个任务进入队列等待,2个任务被拒绝执行 // 2、调用shutdown后,不接收新的任务,等待13任务执行结束 // 3、 追加的任务在线程池关闭后,无法再提交,会被拒绝执行 } /** * 8、 立刻终止线程:线程池信息: 核心线程数量5,最大数量10,队列大小3,超出核心线程数量的线程存活时间:5秒, 指定拒绝策略的 * * @throws Exception */ private void threadPoolExecutorTest8() throws Exception { // 创建一个 核心线程数量为5,最大数量为10,等待队列最大是3 的线程池,也就是最大容纳13个任务。 // 默认的策略是抛出RejectedExecutionException异常,java.util.concurrent.ThreadPoolExecutor.AbortPolicy ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(3), new RejectedExecutionHandler() { @Override public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) { System.err.println("有任务被拒绝执行了"); } }); // 测试: 提交15个执行时间需要3秒的任务,看超过大小的2个,对应的处理情况 for (int i = 0; i < 15; i++) { int n = i; threadPoolExecutor.submit(new Runnable() { @Override public void run() { try { System.out.println("开始执行:" + n); Thread.sleep(3000L); System.err.println("执行结束:" + n); } catch (InterruptedException e) { System.out.println("异常:" + e.getMessage()); } } }); System.out.println("任务提交成功 :" + i); } // 1秒后终止线程池 Thread.sleep(1000L); List<Runnable> shutdownNow = threadPoolExecutor.shutdownNow(); // 再次提交提示失败 threadPoolExecutor.submit(new Runnable() { @Override public void run() { System.out.println("追加一个任务"); } }); System.out.println("未结束的任务有:" + shutdownNow.size()); // 结果分析 // 1、 10个任务被执行,3个任务进入队列等待,2个任务被拒绝执行 // 2、调用shutdownnow后,队列中的3个线程不再执行,10个线程被终止 // 3、 追加的任务在线程池关闭后,无法再提交,会被拒绝执行 } public static void main(String[] args) throws Exception { // new Demo9().threadPoolExecutorTest1(); // new Demo9().threadPoolExecutorTest2(); // new Demo9().threadPoolExecutorTest3(); // new Demo9().threadPoolExecutorTest4(); // new Demo9().threadPoolExecutorTest5(); // new Demo9().threadPoolExecutorTest6(); // new Demo9().threadPoolExecutorTest7(); new Demo9().threadPoolExecutorTest8(); } }
线程池API–Excutors工具类
线程池原理–任务execute过程
如何确定合适数量的线程?
- CPU利用如果没有达到80%,可以考虑增加线程。
相关文章推荐
- 网易云课堂微专业--Java高级开发工程师--多线程并发编程--学习笔记(二)
- Java高级开发工程师面试笔记
- java高级开发工程师学习路线图
- java学习:Java高级开发工程师面试考纲
- <Python高级全栈开发工程师-1>学习过程笔记【181-184】正则表达式 <特殊字符><函数>
- Java开发学习笔记之四:Servlet生命周期
- 对日合作Java、C/C++高级开发工程师/leader
- 黑马程序员学习笔记 JAVA高级视频_其他对象java.lang包中的类System与Runtime
- Java开发学习笔记之八:servlet之间的协作
- 学习笔记:java学习第一课 开发工具,环境配置
- Android高级应用开发(基础篇) - stage2 - 学习笔记
- iPhone/iPad高级应用与手游开发学习笔记:多点触摸与手势检测(三:UIPinchGestureRecognizer和UIRotationGestureRecognizer)
- Java开发学习笔记之十二:JSP语法
- SAP 高级应用开发 学习笔记 1 -- RFC
- 学习笔记9—JAVA高级视频03_图形用户界面GUI
- 《Spring 3.x 企业应用开发实战》学习笔记 第三章 IoC容器概述 3.2 相关Java基础知识 类装载器 反射机制
- Android高级应用开发(基础篇) - stage5 - 学习笔记
- Java学习笔记(十三)——通过Netbeans开发环境生成oracle数据库中表的对应hibernate映射文件
- Java 学习笔记 开发环境搭建JDK+Tomcat+Eclipse
- Java 学习笔记15:关于web开发中,全局变量的一点想法