11.线程的状态，线程池的构造方式，线程池的特性

最新推荐文章于 2023-06-06 14:28:51 发布
最新推荐文章于 2023-06-06 14:28:51 发布
阅读量249 收藏 1
点赞数
分类专栏： 01-线程-初
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WoAiBianCheng123abc/article/details/82913058
版权

目录

一：线程的状态

二：线程池的构造方式

三：线程池的特性

一：线程的状态

（1）初始状态

        实现Runnable接口和继承Thread可以得到一个线程类，new一个实例出来，线程就进入了初始状态。

（2） 就绪状态

      1）就绪状态只是说你资格运行，调度程序没有挑选到你，你就永远是就绪状态。

      2）调用线程的start()方法，此线程进入就绪状态。

     3）当前线程sleep()方法结束，其他线程join()结束，等待用户输入完毕，某个线程拿到对象锁，这些线程也将进入就绪状态。

     4）当前线程时间片用完了，调用当前线程的yield()方法，当前线程进入就绪状态。

     5）锁池里的线程拿到对象锁后，进入就绪状态。

（3）运行中状态

        线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一一种方式。

（4）阻塞状态

        阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态。

（5）等待

       处于这种状态的线程不会被分配CPU执行时间，它们要等待被显式地唤醒，否则会处于无限期等待的状态。

（6） 超时等待

       处于这种状态的线程不会被分配CPU执行时间，不过无须无限期等待被其他线程显示地唤醒，在达到一定时间后它们会自动唤醒。

（7）终止状态

    1）当线程的run()方法完成时，或者主线程的main()方法完成时，我们就认为它终止了。这个线程对象也许是活的，但是，它已经不是一个单独执行的线程。线程一旦终止了，就不能复生。

   2）在一个终止的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常。

 

二：线程池的构造方式

ThreadPoolExecutor的构造函数：

public ThreadPoolExecutor(int corePoolSize,
                                            int maximumPoolSize,
                                            long keepAliveTime,
                                           TimeUnit unit,
                                           BlockingQueue<Runnable> workQueue,
                                           ThreadFactory threadFactory,
                                           RejectedExecutionHandler handler) {

                                           }

函数的参数含义如下：

      corePoolSize： 线程池核心线程数

      maximumPoolSize：线程池最大数

      keepAliveTime： 空闲线程存活时间

      unit： 时间单位

      workQueue： 线程池所使用的缓冲队列

      threadFactory：线程池创建线程使用的工厂

     handler： 线程池对拒绝任务的处理策略

 

三：线程池的特性

    （1）：当池中正在运行的线程数（包括空闲线程）小于corePoolSize时，新建线程执行任务。

下面用实验来说明，代码如下：

public class TestThreadPoolExecutor {
    
    public static void main(String[] args) {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(2, 3, 60L, TimeUnit.SECONDS,new LinkedBlockingQueue<>(1));
        //任务1
        pool.execute(new Runnable() {

            @Override
            public void run() {
                System.out.println("-------------helloworld_001---------------" + Thread.currentThread().getName());
            }
        });
        
        try {
            //主线程睡2秒
            Thread.sleep(2*1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //任务2
        pool.execute(new Runnable() {

            @Override
            public void run() {
                System.out.println("-------------helloworld_002---------------" + Thread.currentThread().getName());
            }
        });
        
    }

}

实验结果如下：

实验结果分析：

      从实验结果上可以看出，当执行任务1的线程（thread-1）执行完成之后，任务2并没有去复用thread-1而是新建线程（thread-2）去执行任务。

    （2）：当池中正在运行的线程数大于等于corePoolSize时，新插入的任务进入workQueue排队（如果workQueue长度允许），等待空闲线程来执行。

下面用实验来说明，代码如下：

public class TestThreadPoolExecutor {

    public static void main(String[] args) {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(2, 3, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1));
        // 任务1
        pool.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3 * 1000);
                    System.out.println("-------------helloworld_001---------------" + Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        // 任务2
        pool.execute(new Runnable() {

            @Override
            public void run() {
                try {
                    Thread.sleep(5 * 1000);
                    System.out.println("-------------helloworld_002---------------" + Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        // 任务3
        pool.execute(new Runnable() {

            @Override
            public void run() {
                System.out.println("-------------helloworld_003---------------" + Thread.currentThread().getName());
            }
        });

    }

}

 实验结果如下：

实验结果分析：

     从实验结果上看，任务3会等待任务1执行完之后，有了空闲线程，才会执行。并没有新建线程执行任务3，这时maximumPoolSize=3这个参数不起作用。

      （3）：当队列里的任务数达到上限，并且池中正在运行的线程数小于maximumPoolSize，对于新加入的任务，新建线程。

下面用实验来说明，代码如下：

public class TestThreadPoolExecutor {

    public static void main(String[] args) {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(2, 3, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1));
        // 任务1
        pool.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3 * 1000);
                    System.out.println("-------------helloworld_001---------------" + Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        // 任务2
        pool.execute(new Runnable() {

            @Override
            public void run() {
                try {
                    Thread.sleep(5 * 1000);
                    System.out.println("-------------helloworld_002---------------" + Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        // 任务3
        pool.execute(new Runnable() {

            @Override
            public void run() {
                System.out.println("-------------helloworld_003---------------" + Thread.currentThread().getName());
            }
        });

        // 任务4
        pool.execute(new Runnable() {

            @Override
            public void run() {
                System.out.println("-------------helloworld_004---------------" + Thread.currentThread().getName());
            }
        });

    }

}

实验结果如下：

实验结果分析：

     当任务4进入队列时发现队列的长度已经到了上限，所以无法进入队列排队，而此时正在运行的线程数（2）小于maximumPoolSize所以新建线程执行该任务。

      （4）：当队列里的任务数达到上限，并且池中正在运行的线程数等于maximumPoolSize，对于新加入的任务，执行拒绝策略（线程池默认的拒绝策略是抛异常）。

下面用实验来说明，代码如下：

public class TestThreadPoolExecutor {

    public static void main(String[] args) {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(2, 3, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1));
        // 任务1
        pool.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3 * 1000);
                    System.out.println("-------------helloworld_001---------------" + Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        // 任务2
        pool.execute(new Runnable() {

            @Override
            public void run() {
                try {
                    Thread.sleep(5 * 1000);
                    System.out.println("-------------helloworld_002---------------" + Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        // 任务3
        pool.execute(new Runnable() {

            @Override
            public void run() {
                System.out.println("-------------helloworld_003---------------" + Thread.currentThread().getName());
            }
        });

        // 任务4
        pool.execute(new Runnable() {

            @Override
            public void run() {
                try {
                    Thread.sleep(2 * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("-------------helloworld_004---------------" + Thread.currentThread().getName());
            }
        });

        // 任务5
        pool.execute(new Runnable() {

            @Override
            public void run() {
                System.out.println("-------------helloworld_005---------------" + Thread.currentThread().getName());
            }
        });

    }

}

实验结果如下：

实验结果分析：

当任务5加入时，队列达到上限，池内运行的线程数达到最大，故执行默认的拒绝策略，抛异常。

      队列类型虽然仅限于LinkedBlockingQueue这一种队列类型，但总结出来的特性，对与常用ArrayBlockingQueue 和 SynchronousQueue同样适用。

 

蚂蚁@叔叔
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
回顾线程池的几种状态
calm_encode的博客
07-27 202
一概述 二 线程池不同状态 Running状态：表示线程池处于正常运行的状态，能够接收新任务，同时能够将新的任务加到处理队列中。SHUTDOWN状态：状态一的线程池执行shutDown()方法后，此时的线程池不再接受新任务，队列中的任务会被执行完毕。STOP状态：状态一的线程池执行shutDownNow()方法后，此时的线程池不再接受新任务，队列中的任务不会被执行完毕，而时被丢弃，正在执行的任务也会被丢弃。TIDYING状态：当线程池中的任务为空的时候，及所有的任务都被终止的状态。TERMINATE
【Java多线程】基础知识二、java线程的几种状态，synchronized锁注意点以及原理详解
Passer_hua的博客
03-30 246
多线程的基础知识，主要讲解了线程的几种状态，synchronized锁注意点以及原理详解。
线程池都有哪些状态？
m0_68464502的博客
06-06 2207
5. Terminated（终止状态）：当线程池处于Shutdown状态，并且等待队列中的任务全部执行完毕，或者在Stop状态下，线程池内部的所有线程都已经终止时，线程池进入Terminated状态。4. Tidying（整理状态）：当线程池处于Shutdown或Stop状态时，如果等待队列中还有未执行的任务，则线程池将执行整理操作，将等待队列中的未执行任务移除，并保存到一个列表中。2. Shutdown（关闭状态）：线程池调用shutdown()方法后，线程池的状态会变为Shutdown。
线程的几种状态,四种常见的线程池的介绍
zzzgd_666的博客
06-25 1856
0. 什么是同步和有异步 同步:发送一个请求,等待返回,然后再发送下一个请求,线程和进程按照顺序依次运行 异步:发送一个请求,不等待返回,随时可以再发送下一个请求 同步可以避免死锁,异步可以提高效率 1. 线程的几种状态: 新建状态(new) : 新创建了一个线程对象 可运行状态 : 其他线程调用了这个线程的start()方法. 这个线程被放到可运行线程池中,等待获取CPU的使...
线程池有哪几种状态，分别是如何发生变化的？
qq_34069570的博客
11-30 503
线程池有哪几种状态，分别是如何发生变化的？
Java中的线程与线程池.pptx
最新发布
01-20
2. newSingleThreadExecutor：创建一个单线程线程池，所有任务都在一个线程中顺序执行，保证了任务的执行顺序。 3. newFixedThreadPool：创建一个固定大小的线程池，线程数量保持不变，任务排队等待执行。 4. ...
浅谈java.util.concurrent包中的线程池和消息队列
08-25
java.util.concurrent包是JDK5.0（JDK1.5更名后）引入的高级并发特性，主要包括原子量、并发集合、同步器、可重入锁，并对线程池的构造提供了强力的支持。该包充分利用了现代多处理器和多核心系统的功能，以编写大...
c++11线程与线程池Demo 完整vs2013工程
12-09
C++11是C++语言的一个重要版本更新，它引入了大量的新特性，其中包括对多线程编程的支持。在这个“c++11线程与线程池Demo 完整vs2013工程”中，我们可以深入理解C++11如何通过`<thread>`库来实现线程管理和线程池的...
完全解析Android多线程中线程池ThreadPool的原理和使用
01-20
线程池是多线程编程中的一个重要概念，...理解线程池的工作原理和使用方式，可以帮助开发者更好地管理多线程环境，提高程序的稳定性和性能。在Android开发中，合理使用线程池是优化用户体验和提升应用质量的关键之一。
java线程和线程池的使用.docx
11-20
线程池可以调整参数以优化性能，如核心线程数、最大线程数、线程空闲时间等，这些参数在 `ThreadPoolExecutor` 构造函数中指定。 总结来说，Java 线程用于实现并发处理，而线程池提供了更高级别的线程管理，能够...
线程池有哪些状态？状态是如何转换的？
开源世界
03-24 4980
在 Java 中，线程池的状态和线程的状态是完全不同的，线程有 6 种状态：NEW：初始化状态、RUNNABLE：可运行/运行状态、BLOCKED：阻塞状态、WAITING：无时限等待状态、TIMED_WAITING：有时限等待状态和 TERMINATED：终止状态。而线程池的状态有以下 5 种： RUNNING：运行状态，线程池创建好之后就会进入此状态，如果不手动调用关闭方法，那么线程池在整个程序运行期间都是此状态。 SHUTDOWN：关闭状态，不再接受新任务提交，但是会将已保存在任务队列中的任务处理完。
线程池有哪些状态？
ConstXiong
05-16 9690
线程池有哪些状态？ 线程池的5种状态：RUNNING、SHUTDOWN、STOP、TIDYING、TERMINATED。 见 ThreadPoolExecutor 源码 // runState is stored in the high-order bits private static final int RUNNING = -1 << COUNT_BITS...
[线程池] 关于线程池的五种状态
my_momo_csdn的博客
11-05 1316
线程状态 在ThreadPoolExecutor类中定义了线程的五种状态表示，通过AtomicInteger 的高三位来表示线程的状态： private static final int COUNT_BITS = Integer.SIZE - 3; private static final int RUNNING = -1 &amp;amp;amp;amp;amp;lt;&amp;amp;amp;amp;amp;lt; COUNT_BITS; p...
深入理解Thread.sleep(1000)的注意事项及原理分析
专注Java实用技术分享
09-13 7288
最近服务器上出现了一次长时间的STW，原因也比较诡异.通过jstack分析，可疑代码居然是Thread.sleep(1000)。
线程thread 使用，和运行结束判断
08-11 983
Console.WriteLine(DateTime.Now + "thread 等待结束!// 默认是前台线程。//线程等待200ms。
线程（一）
WinnerBear的博客
11-25 1211
线程
关于多线程中的Thread.sleep方法以及面试相关
m0_47739580的博客
06-30 1885
多线程中sleep方法详解，以及与sleep有关的面试题
Thread.Sleep(1000) 、Task.Delay(1000).Wait() 区别
热门推荐
wushang923的专栏
11-11 1万+
We can use both Thread.Sleep() and Task.Delay() to suspend the execution of a program for some given time. But are we actually suspending the execution? What is the difference between these two? How
Thread.sleep(1000)
weixin_30786657的博客
02-16 3486
public class Wait { public static void main(String[] args) { System.out.println(System.currentTimeMillis()); //程序暂停1000ms try { Thread....
java 线程池调用线程 线程构造
07-20
在 Java 中使用线程池来调用线程可以使用以下步骤： 1. 导入相关的类： ```java import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; ``` 2. 创建一个线程池： ```java ExecutorService executor = Executors.newFixedThreadPool(5); // 创建一个固定大小为5的线程池 ``` 3. 创建一个实现了Runnable接口的线程类： ```java class MyThread implements Runnable { @Override public void run() { // 线程执行的代码逻辑 } } ``` 4. 提交任务给线程池： ```java executor.submit(new MyThread()); // 提交一个实现了Runnable接口的线程任务给线程池执行 ``` 5. 关闭线程池： ```java executor.shutdown(); // 执行完所有任务后关闭线程池 ``` 这样就可以通过线程池来调用并执行线程了。注意，使用线程池可以更好地管理和复用线程资源，提高程序的性能和效率。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值