Java多线程详解二-CSDN博客

本文链接：https://blog.csdn.net/qq_45904092/article/details/134717499

文章目录

线程状态

线程状态介绍

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。线程对象在不同的时期有不同的状态。那么Java中的线程存在哪几种状态呢？Java中的线程

状态被定义在了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	一个完全运行完成的线程的状态。也称之为终止状态、结束状态

各个状态的转换，如下图所示：
在这里插入图片描述
本案例主要演示TIME_WAITING的状态转换。

需求：编写一段代码，依次显示一个线程的这些状态：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状态
        //用main线程来获取thread1线程的状态，因为thread1线程睡眠时间较长
        //所以当main线程执行的时候，thread1线程还没有睡醒，还处于计时等待状态
        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.创建一个池子池子中是空的
2.提交任务时，池子会创建新的线程对象，任务执行完毕，线程归还给池子，下次在提交任务时，不需要创建新的线程，直接复用已有的线程。
3.但如果提交任务时，池子中没有空闲的线程，也无法创建新的线程，任务就会排队等待。

创建线程池

JDK对线程池也进行了相关的实现，在真实企业开发中我们也很少去自定义线程池，而是使用JDK中自带的线程池。
我们可以使用Executors中所提供的静态方法来创建线程池。

通过不同的方法创建出来的线程池具有不同的特点。

方法名	说明
ExecutorService newCachedThreadPool()	创建一个可缓存线程池，可灵活的去创建线程，并且灵活的回收线程，若无可回收，则新建线程。
ExecutorService newFixedThreadPool(int nThreads)	初始化一个具有固定数量线程的线程池
ExecutorService newSingleThreadExecutor()	初始化一个具有一个线程的线程池。做完一个，再做一个，不停歇，直到做完。
ScheduledExecutorService newSingleThreadScheduledExecutor()	初始化一个具有一个线程的线程池，支持定时及周期性任务执行。按照固定的计划去执行线程，一个做完之后按照计划再做另一个

这些方法返回的都是ExecutorService类型的对象(ScheduledExecutorService继承ExecutorService),而ExecutorService可以看做就是一个线程池。

ExecutorService中常见的方法

方法	说明
Future<?> submit(Runnable task)	提交任务方法
void shutdown()	关闭线程池的方法

public class MyRunable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i <= 10; i++) {
            System.out.println(Thread.currentThread().getName() + ": " + i);
        }
    }
}

public class MyThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        /*
        public static ExecutorService newCachedThreadPool()             创建一个没有上限的线程池
        public static ExecutorService newFixedThreadPool (int nThreads) 创建有上限的线程池
        */
        //1.获取线程池对象
//        ExecutorService pool1 = Executors.newCachedThreadPool();

        //最多三个线程
        ExecutorService pool2 = Executors.newFixedThreadPool(2);

        //2.提交任务
//        pool1.submit(new MyRunable());
//        pool1.submit(new MyRunable());
//        pool1.submit(new MyRunable());

        pool2.submit(new MyRunable());
        pool2.submit(new MyRunable());
        pool2.submit(new MyRunable());
        
        //3.销毁线程池
//        pool1.shutdown();
        pool2.shutdown();
    }
}

自定义线程池

自定义好线程池之后，和上方JDK中自带的线程池ExecutorService 一样进行提交即可

public class MyThreadPoolDemo1  {
    public static void main(String[] args) {
            /*
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor
        (核心线程数量,最大线程数量,空闲线程最大存活时间,任务队列,创建线程工厂,任务的拒绝策略);

        参数一：核心线程数量              不能小于0
        参数二：最大线程数                不能小于0，最大数量 >= 核心线程数量
        参数三：空闲线程最大存活时间       不能小于0
        参数四：时间单位                  用TimeUnit指定
        参数五：任务队列                  不能为null
        参数六：创建线程工厂              不能为null
        参数七：任务的拒绝策略             不能为null
    */

        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                3,  //核心线程数量              不能小于0
                6,  //最大线程数                不能小于0，最大数量 >= 核心线程数量
                60,    //空闲线程最大存活时间       不能小于0
                TimeUnit.SECONDS,   //时间单位                  用TimeUnit指定
                new ArrayBlockingQueue<>(3),     //任务队列                  不能为null
                Executors.defaultThreadFactory(),    //创建线程工厂              不能为null
                new ThreadPoolExecutor.AbortPolicy()    //任务的拒绝策略             不能为null
        );
    }
}