线程池和volatile
状态被定义在了java.lang.Thread.State枚举类中，State枚举类的源码如下：
public class Thread { public enum State { /* 新建 */ NEW , /* 可运行状态 */ RUNNABLE , /* 阻塞状态 */ BLOCKED , /* 无限等待状态 */ WAITING , /* 计时等待 */ TIMED_WAITING , /* 终止 */ TERMINATED; } // 获取当前线程的状态 public State getState() { return jdk.internal.misc.VM.toThreadState(threadStatus); } }
通过源码我们可以看到Java中的线程存在6种状态，每种线程状态的含义如下：
| 线程状态 | 具体含义 |
|---|---|
| NEW | 一个尚未启动的线程的状态。也称之为初始状态、开始状态。线程刚被创建，但是并未启动。还没调用start方法。MyThread t = new MyThread()只有线程象，没有线程特征。 |
| RUNNABLE | 当我们调用线程对象的start方法，那么此时线程对象进入了RUNNABLE状态。那么此时才是真正的在JVM进程中创建了一个线程，线程一经启动并不是立即得到执行，线程的运行与否要听令与CPU的调度，那么我们把这个中间状态称之为可执行状态(RUNNABLE)也就是说它具备执行的资格，但是并没有真正的执行起来而是在等待CPU的度。 |
| BLOCKED | 当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。 |
| WAITING | 一个正在等待的线程的状态。也称之为等待状态。造成线程等待的原因有两种，分别是调用Object.wait()、join()方法。处于等待状态的线程，正在等待其他线程去执行一个特定的操作。例如：因为wait()而等待的线程正在等待另一个线程去调用notify()或notifyAll()；一个因为join()而等待的线程正在等待另一个线程结束。 |
| TIMED_WAITING | 一个在限定时间内等待的线程的状态。也称之为限时等待状态。造成线程限时等待状态的原因有三种，分别是：Thread.sleep(long)，Object.wait(long)、join(long)。 |
| TERMINATED | 一个完全运行完成的线程的状态。也称之为终止状态、结束状态 |
各个状态的转换，如下图所示：
需求：编写一段代码，依次显示一个线程的这些状态：NEW -> RUNNABLE -> TIME_WAITING -> RUNNABLE -> TERMINATED
为了简化我们的开发，本次我们使用匿名内部类结合lambda表达式的方式使用多线程。
代码实现
public class ThreadStateDemo01 { public static void main(String[] args) throws InterruptedException { //定义一个内部线程 Thread thread = new Thread(() -> { System.out.println("2.执行thread.start()之后，线程的状态：" + Thread.currentThread().getState()); try { //休眠100毫秒 Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("4.执行Thread.sleep(long)完成之后，线程的状态：" + Thread.currentThread().getState()); }); //获取start()之前的状态 System.out.println("1.通过new初始化一个线程，但是还没有start()之前，线程的状态：" + thread.getState()); //启动线程 thread.start(); //休眠50毫秒 Thread.sleep(50); //因为thread1需要休眠100毫秒，所以在第50毫秒，thread处于sleep状态 System.out.println("3.执行Thread.sleep(long)时，线程的状态：" + thread.getState()); //thread1和main线程主动休眠150毫秒，所以在第150毫秒,thread早已执行完毕 Thread.sleep(100); System.out.println("5.线程执行完毕之后，线程的状态：" + thread.getState() + "\n"); } }
控制台输出
1.通过new初始化一个线程，但是还没有start()之前，线程的状态：NEW 2.执行thread.start()之后，线程的状态：RUNNABLE 3.执行Thread.sleep(long)时，线程的状态：TIMED_WAITING 4.执行Thread.sleep(long)完成之后，线程的状态：RUNNABLE 5.线程执行完毕之后，线程的状态：TERMINATED
需求 ：编写一段代码，依次显示一个线程的这些状态：NEW -> RUNNABLE -> WAITING -> RUNNABLE -> TERMINATED
代码实现 :
public class ThreadStateDemo02 { public static void main(String[] args) throws InterruptedException { //定义一个对象，用来加锁和解锁 Object obj = new Object(); //定义一个内部线程 Thread thread1 = new Thread(() -> { System.out.println("2.执行thread.start()之后，线程的状态：" + Thread.currentThread().getState()); synchronized (obj) { try { //thread1需要休眠100毫秒 Thread.sleep(100); //thread1100毫秒之后，通过wait()方法释放obj对象是锁 obj.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("4.被object.notify()方法唤醒之后，线程的状态：" + Thread.currentThread().getState()); }); //获取start()之前的状态 System.out.println("1.通过new初始化一个线程，但是还没有start()之前，线程的状态：" + thread1.getState()); //启动线程 thread1.start(); //main线程休眠150毫秒 Thread.sleep(150); //因为thread1在第100毫秒进入wait等待状态，所以第150秒肯定可以获取其状态 System.out.println("3.执行object.wait()时，线程的状态：" + thread1.getState()); //声明另一个线程进行解锁 new Thread(() -> { synchronized (obj) { //唤醒等待的线程 obj.notify(); } }).start(); //main线程休眠10毫秒等待thread1线程能够苏醒 Thread.sleep(10); //获取thread1运行结束之后的状态 System.out.println("5.线程执行完毕之后，线程的状态：" + thread1.getState() + "\n"); } }
控制台输出结果
1.通过new初始化一个线程，但是还没有start()之前，线程的状态：NEW 2.执行thread.start()之后，线程的状态：RUNNABLE 3.执行object.wait()时，线程的状态：WAITING 4.被object.notify()方法唤醒之后，线程的状态：RUNNABLE 5.线程执行完毕之后，线程的状态：TERMINATED
需求 ：编写一段代码，依次显示一个线程的这些状态：NEW -> RUNNABLE -> BLOCKED -> RUNNABLE -> TERMINATED
public class ThreadStateDemo03 { public static void main(String[] args) throws InterruptedException { //定义一个对象，用来加锁和解锁 Object obj2 = new Object(); //定义一个线程，先抢占了obj2对象的锁 new Thread(() -> { synchronized (obj2) { try { Thread.sleep(100); //第一个线程要持有锁100毫秒 obj2.wait(); //然后通过wait()方法进行等待状态，并释放obj2的对象锁 } catch (InterruptedException e) { e.printStackTrace(); } } }).start(); //定义目标线程，获取等待获取obj2的锁 Thread thread = new Thread(() -> { System.out.println("2.执行thread.start()之后，线程的状态：" + Thread.currentThread().getState()); synchronized (obj2) { try { Thread.sleep(100); //thread3要持有对象锁100毫秒 obj2.notify(); //然后通过notify()方法唤醒所有在ojb2上等待的线程继续执行后续操作 } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("4.阻塞结束后，线程的状态：" + Thread.currentThread().getState()); }); //获取start()之前的状态 System.out.println("1.通过new初始化一个线程，但是还没有thread.start()之前，线程的状态：" + thread.getState()); //启动线程 thread.start(); //先等100毫秒 Thread.sleep(50); //第一个线程释放锁至少需要100毫秒，所以在第50毫秒时，thread正在因等待obj的对象锁而阻塞 System.out.println("3.因为等待锁而阻塞时，线程的状态：" + thread.getState()); //再等300毫秒 Thread.sleep(300); //两个线程的执行时间加上之前等待的50毫秒总共是250毫秒，所以第300毫秒，所有的线程都已经执行完毕 System.out.println("5.线程执行完毕之后，线程的状态：" + thread.getState()); } }
控制台输出结果
1.通过new初始化一个线程，但是还没有thread.start()之前，线程的状态：NEW 2.执行thread.start()之后，线程的状态：RUNNABLE 3.因为等待锁而阻塞时，线程的状态：BLOCKED 4.阻塞结束后，线程的状态：RUNNABLE 5.线程执行完毕之后，线程的状态：TERMINATED
线程池-基本原理
概述 :
提到池，大家应该能想到的就是水池。水池就是一个容器，在该容器中存储了很多的水。那么什么是线程池呢？线程池也是可以看做成一个池子，在该池子中存储很多个线程。
线程池存在的意义：
系统创建一个线程的成本是比较高的，因为它涉及到与操作系统交互，当程序中需要创建大量生存期很短暂的线程时，频繁的创建和销毁线程对系统的资源消耗有可能大于业务处理是对系统资源的消耗，这样就有点"舍本逐末"了。针对这一种情况，为了提高性能，我们就可以采用线程池。线程池在启动的时，会创建大量空闲线程，当我们向线程池提交任务的时，线程池就会启动一个线程来执行该任务。等待任务执行完毕以后，线程并不会死亡，而是再次返回到线程池中称为空闲状态。等待下一次任务的执行。
线程池的设计思路 :
-
准备一个任务容器
-
一次性启动多个(2个)消费者线程
-
刚开始任务容器是空的，所以线程都在wait
-
直到一个外部线程向这个任务容器中扔了一个"任务"，就会有一个消费者线程被唤醒
-
这个消费者线程取出"任务"，并且执行这个任务，执行完毕后，继续等待下一次任务的到来
概述 : JDK对线程池也进行了相关的实现，在真实企业开发中我们也很少去自定义线程池，而是使用JDK中自带的线程池。
我们可以使用Executors中所提供的静态方法来创建线程池
static ExecutorService newCachedThreadPool() 创建一个默认的线程池static newFixedThreadPool(int nThreads) 创建一个指定最多线程数量的线程池
代码实现：
package com.itheima.mythreadpool; //static ExecutorService newCachedThreadPool() 创建一个默认的线程池 //static newFixedThreadPool(int nThreads) 创建一个指定最多线程数量的线程池 import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class MyThreadPoolDemo { public static void main(String[] args) throws InterruptedException { //1,创建一个默认的线程池对象.池子中默认是空的.默认最多可以容纳int类型的最大值. ExecutorService executorService = Executors.newCachedThreadPool(); //Executors --- 可以帮助我们创建线程池对象 //ExecutorService --- 可以帮助我们控制线程池 executorService.submit(()->{ System.out.println(Thread.currentThread().getName() + "在执行了"); }); //Thread.sleep(2000); executorService.submit(()->{ System.out.println(Thread.currentThread().getName() + "在执行了"); }); executorService.shutdown(); } }
使用Executors中所提供的静态方法来创建线程池
static ExecutorService newFixedThreadPool(int nThreads) : 创建一个指定最多线程数量的线程池
代码实现 :
package com.itheima.mythreadpool; //static ExecutorService newFixedThreadPool(int nThreads) //创建一个指定最多线程数量的线程池 import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.ThreadPoolExecutor; public class MyThreadPoolDemo2 { public static void main(String[] args) { //参数不是初始值而是最大值 ExecutorService executorService = Executors.newFixedThreadPool(10); ThreadPoolExecutor pool = (ThreadPoolExecutor) executorService; System.out.println(pool.getPoolSize());//0 executorService.submit(()->{ System.out.println(Thread.currentThread().getName() + "在执行了"); }); executorService.submit(()->{ System.out.println(Thread.currentThread().getName() + "在执行了"); }); System.out.println(pool.getPoolSize());//2 // executorService.shutdown(); } }
创建线程池对象 :
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(核心线程数量,最大线程数量,空闲线程最大存活时间,任务队列,创建线程工厂,任务的拒绝策略);
package com.itheima.mythreadpool; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.Executors; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; public class MyThreadPoolDemo3 { // 参数一：核心线程数量 // 参数二：最大线程数 // 参数三：空闲线程最大存活时间 // 参数四：时间单位 // 参数五：任务队列 // 参数六：创建线程工厂 // 参数七：任务的拒绝策略 public static void main(String[] args) { ThreadPoolExecutor pool = new ThreadPoolExecutor(2,5,2,TimeUnit.SECONDS,new ArrayBlockingQueue<>(10), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy()); pool.submit(new MyRunnable()); pool.submit(new MyRunnable()); pool.shutdown(); } }
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) corePoolSize： 核心线程的最大值，不能小于0 maximumPoolSize：最大线程数，不能小于等于0，maximumPoolSize >= corePoolSize keepAliveTime： 空闲线程最大存活时间,不能小于0 unit： 时间单位 workQueue： 任务队列，不能为null threadFactory： 创建线程工厂,不能为null handler： 任务的拒绝策略,不能为null
ThreadPoolExecutor.AbortPolicy: 丢弃任务并抛出RejectedExecutionException异常。是默认的策略。
ThreadPoolExecutor.DiscardPolicy： 丢弃任务，但是不抛出异常 这是不推荐的做法。
ThreadPoolExecutor.DiscardOldestPolicy： 抛弃队列中等待最久的任务 然后把当前任务加入队列中。
ThreadPoolExecutor.CallerRunsPolicy: 调用任务的run()方法绕过线程池直接执行。
注：明确线程池对多可执行的任务数 = 队列容量 + 最大线程数
案例演示1：演示ThreadPoolExecutor.AbortPolicy任务处理策略
public class ThreadPoolExecutorDemo01 { public static void main(String[] args) { /** * 核心线程数量为1 ， 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s */ ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS , new ArrayBlockingQueue<>(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.AbortPolicy()) ; // 提交5个任务，而该线程池最多可以处理4个任务，当我们使用AbortPolicy这个任务处理策略的时候，就会抛出异常 for(int x = 0 ; x < 5 ; x++) { threadPoolExecutor.submit(() -> { System.out.println(Thread.currentThread().getName() + "---->> 执行了任务"); }); } } }
控制台输出结果
pool-1-thread-1---->> 执行了任务 pool-1-thread-3---->> 执行了任务 pool-1-thread-2---->> 执行了任务 pool-1-thread-3---->> 执行了任务
控制台报错，仅仅执行了4个任务，有一个任务被丢弃了
public class ThreadPoolExecutorDemo02 { public static void main(String[] args) { /** * 核心线程数量为1 ， 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s */ ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS , new ArrayBlockingQueue<>(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.DiscardPolicy()) ; // 提交5个任务，而该线程池最多可以处理4个任务，当我们使用DiscardPolicy这个任务处理策略的时候，控制台不会报错 for(int x = 0 ; x < 5 ; x++) { threadPoolExecutor.submit(() -> { System.out.println(Thread.currentThread().getName() + "---->> 执行了任务"); }); } } }
控制台输出结果
pool-1-thread-1---->> 执行了任务 pool-1-thread-1---->> 执行了任务 pool-1-thread-3---->> 执行了任务 pool-1-thread-2---->> 执行了任务
控制台没有报错，仅仅执行了4个任务，有一个任务被丢弃了
public class ThreadPoolExecutorDemo02 { public static void main(String[] args) { /** * 核心线程数量为1 ， 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s */ ThreadPoolExecutor threadPoolExecutor; threadPoolExecutor = new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS , new ArrayBlockingQueue<>(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.DiscardOldestPolicy()); // 提交5个任务 for(int x = 0 ; x < 5 ; x++) { // 定义一个变量，来指定指定当前执行的任务;这个变量需要被final修饰 final int y = x ; threadPoolExecutor.submit(() -> { System.out.println(Thread.currentThread().getName() + "---->> 执行了任务" + y); }); } } }
由于任务1在线程池中等待时间最长，因此任务1被丢弃。
public class ThreadPoolExecutorDemo04 { public static void main(String[] args) { /** * 核心线程数量为1 ， 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s */ ThreadPoolExecutor threadPoolExecutor; threadPoolExecutor = new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS , new ArrayBlockingQueue<>(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.CallerRunsPolicy()); // 提交5个任务 for(int x = 0 ; x < 5 ; x++) { threadPoolExecutor.submit(() -> { System.out.println(Thread.currentThread().getName() + "---->> 执行了任务"); }); } } }
控制台输出结果
pool-1-thread-1---->> 执行了任务 pool-1-thread-3---->> 执行了任务 pool-1-thread-2---->> 执行了任务 pool-1-thread-1---->> 执行了任务 main---->> 执行了任务
通过控制台的输出，我们可以看到次策略没有通过线程池中的线程执行任务，而是直接调用任务的run()方法绕过线程池直接执行。
