多线程基础

已于 2023-11-28 14:07:54 修改
阅读量51 收藏
点赞数
分类专栏： 多线程 文章标签： java ide
于 2023-08-11 15:33:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50405726/article/details/132229127
版权
本文详细介绍了Java多线程的六种状态（New、Runnable、Blocked、Waiting、TimedWaiting、Terminated），并通过示例展示了线程生命周期的过程，包括如何正确终止线程（如使用interrupt而非stop）以及使用标志位控制线程执行。
摘要由CSDN通过智能技术生成

多线程学习记录，勿喷谢谢

一、多线程的六种状态

1. New : 尚未启动的线程状态。
2. Runnable : 可运行线程的线程状态，等待CPU调度或处于运行的线程。
3. Blocked : 线程阻塞等待监视器锁定的线程状态，处于synchronized同步代码块或方法中被阻塞。
4. Waiting : 无限期等待状态。

                     Object.wait 、Thread.join、LockSupport.park

5. Timed Waiting : 有限期等待状态。

                     Thread.sleep、Object.wait 、 Thread.join 、 LockSupport.parkNanos、LockSupport.parkUntil

6. Terminated : 终止线程的线程状态。线程正常完成执行或异常退出。

二、实例

1. 新建->运行->结束

package com.threadTest.demo2;

public class ThreadType {

    public static void main(String[] args) throws InterruptedException {
        System.out.println("状态为：  新建 -> 运行 -> 终止 ");
        //创建线程对象
        Thread thread1 = new Thread(() -> {
            //运行状态
            System.out.println("调用start后thread的状态为: " + Thread.currentThread().getState().toString());
        });
        //新建状态
        System.out.println("没调用start方法时，thread的状态为"+thread1.getState().toString());
        //线程开启
        thread1.start();
        Thread.sleep(2000);
        //终止状态
        System.out.println("等待两秒，再看thread1当前状态："+ thread1.getState().toString());
        //thread1.start();  若线程已经终止后，在调用运行thread1.start();  会抛出IllegalTheadStateException异常
    
        /**
         * 状态为：  新建 -> 运行 -> 终止

         * 没调用start方法时，thread的状态为 NEW 新建
         * 调用start后thread的状态为: RUNNABLE  运行
         * 等待两秒，再看thread1当前状态：TERMINATED 终止
         */

    }
}

2. 新建 -> 运行 -> 堵塞 -> 运行 -> 终止

package com.threadTest.demo2;

public class ThreadType {


    public static void main(String[] args) throws InterruptedException {
    
        System.out.println("状态为：  新建 -> 运行 -> 堵塞 -> 运行 -> 终止");
        //创建线程对象
        Thread thread1 = new Thread(() -> {
            synchronized (ThreadType.class){
                System.out.println("thread当前状态: " + Thread.currentThread().getState().toString());
            }
        });
        // 2个锁使用同一个对象，所以线程会堵塞，
        //等下方锁释放后，线程的锁才会执行 从堵塞状态切换到运行状态
        synchronized (ThreadType.class){
            //新建状态
            System.out.println("没调用start方法，thread当前状态"+thread1.getState().toString());
            //线程启动
            thread1.start();
            Thread.sleep(200);//等待200毫秒，让线程执行到锁代码
            //堵塞状态
            System.out.println("等待200毫秒，再看thread当前状态："+ thread1.getState().toString());
        }
        //上方锁释放，线程锁可以运行了
        Thread.sleep(3000);//等待3秒，让线程执行
        System.out.println("等待3秒，再看thread1当前状态："+ thread1.getState().toString());
        //thread1.start();  若线程已经终止后，在调用运行thread1.start();  会抛出IllegalTheadStateException异常
        /**
         * 状态为：  新建 -> 运行 -> 堵塞 -> 运行 -> 终止
         * 没调用start方法，thread当前状态NEW 新建
         * 等待200毫秒，再看thread当前状态：BLOCKED 堵塞
         * thread当前状态: RUNNABLE 运行
         * 等待3秒，再看thread1当前状态：TERMINATED 终止

         */
    }
}

 3.新建->运行->等待(有限期) ->终止

package com.threadTest.demo2;

public class ThreadType {

    public static void main(String[] args) throws InterruptedException {
        //状态 ： 新建 -> 运行 -> 等待(带时间的等待) -> 终止
        System.out.println("状态切换： 新建 -> 运行 -> 等待(带时间的等待) ->运行 ->  终止");
        //创建线程对象
        Thread thread1 = new Thread(() -> {
            try {
                //等待1.5秒
                Thread.sleep(1500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        });
        //新建状态
        System.out.println("没调用start方法，thread当前状态"+thread1.getState().toString());
        //线程启动
        thread1.start();
        Thread.sleep(200);//等待200毫秒，让线程执行
        //等待
        System.out.println("等待200毫秒，再看thread当前状态："+ thread1.getState().toString());
        Thread.sleep(3000);//在等待3秒，让线程执行完成
        //终止
        System.out.println("等待3秒，再看thread1当前状态："+ thread1.getState().toString());
        //thread1.start();  若线程已经终止后，在调用运行thread1.start();  会抛出IllegalTheadStateException异常
        /**
         * 状态切换： 新建 -> 运行 -> 等待(带时间的等待) ->运行 ->  终止
         * 没调用start方法，thread当前状态NEW 新建
         * 等待200毫秒，再看thread当前状态：TIMED_WAITING 等待
         * 等待3秒，再看thread1当前状态：TERMINATED 终止
        
         */
    }
}

三、线程终止

1. stop jdk已经弃用  ，建议使用 interrupt()  

package com.threadTest.demo2;

public class ThreadStop {
    private static Integer i = 0;
    private static Integer y = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
                ++i;
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    System.out.println("使用interrupt终止程序，抓取InterruptedException，可进行异常处理");
                    y=20;
                }
                ++y;
            
        });


        thread.start();
        //休眠1秒 确保++i 成功
        Thread.sleep(1000);
        //暂停线程
        //thread.stop();//错误的终止
        // todo stop:i=1y=0   直接终止，没有报异常，无法进行异常处理

        thread.interrupt();//正确的终止 
        //todo interrupt：i=1y=21  将线程执行完成，y=20后 在执行 ++Y  并进入异常处理
        /**
         * java.lang.InterruptedException: sleep interrupted
         * 	at java.lang.Thread.sleep(Native Method)
         * 	at com.threadTest.demo2.ThreadStop.lambda$main$0(ThreadStop.java:12)
         * 	at java.lang.Thread.run(Thread.java:748)
         * 使用interrupt终止程序，抓取InterruptedException，可进行异常处理
         * i=1y=21
         */
        System.out.println(thread.getState().toString());
        //等待10秒 打印 i与y的状态
        Thread.sleep(10000);
        sout();
    }


    public static void sout(){
        System.out.println("i=" + i + "y=" + y);
    }


}

2. 使用标志位

package com.threadTest.demo2;


public class ThreadStop {

    //标志位
    private static boolean flag = true;


    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            while (flag) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程运行中");
            }
            System.out.println("线程结束");
        });
        thread.start();
        Thread.sleep(2000);
        //更改标志位状态
        flag = false;
        System.out.println("更改标志位状态，会出现延时生效情况");
        Thread.sleep(1000);
        System.out.println("线程状态=" + thread.getState().toString());

        /**
         * 线程运行中
         * 更改标志位状态，会出现延时生效情况
         * 线程运行中
         * 线程结束
         * 线程状态=TERMINATED
         *
         * 或
         *
         * 线程运行中
         * 线程运行中
         * 更改标志位状态，会出现延时生效情况
         * 线程结束
         * 线程状态=TERMINATED
         */

// 这里要注意一下，使用标志位有一个坑，当判断标志位的if语句无法执行时，便无法停止线程

    }


}

// 这里要注意一下，使用标志位有一个坑，当判断标志位的if语句无法执行时，便无法停止线程
 

标志位bug演示

package com.design.domain;

public class FlagBit {
    private static volatile boolean bit = true;

    public static void main(String[] args) throws InterruptedException {
        //创建线程
        Thread thread = new Thread() {
            @Override
            public void run() {
                System.out.println("线程执行");
                //判断标志位
                if (bit) {
                    try {
                        // 模拟无限堵塞时间
                        Thread.sleep(1000000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("线程执行完成");
            }
        };
        //开启线程
        thread.start();
        Thread.sleep(1000);
        //更改标志位
        bit = false;
        //thread.interrupt();
        Thread.sleep(1000);
        System.out.println("线程状态=" + thread.getState().toString());

        //执行结果为：无法中断线程。  建议使用thread.interrupt();
        // 因为线程在进入无限堵塞后，无法在执行if判断，所以更改标志位无法结束程序

        /**  标志位代码
         * 线程执行
         * 更改标志位
         * 线程状态=TIMED_WAITING 堵塞
         * 无法中断
         */

        //thread.interrupt(); 方法会中断线程并抛出异常
        /**
         * 线程执行
         * thread.interrupt();中断线程
         * 线程执行完成
         * java.lang.InterruptedException: sleep interrupted
         * 	at java.lang.Thread.sleep(Native Method)
         * 	at com.design.domain.FlagBit$1.run(FlagBit.java:16)
         * 线程状态=TERMINATED
         */
    }
}

起飞的猪^(*￣(oo)￣)^
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
多线程基础代码.rar
07-05
"多线程基础代码.rar"这个压缩包文件很可能是包含了一些关于多线程编程的基础示例代码，用于帮助初学者理解和实践多线程技术。 多线程允许一个应用程序同时执行多个不同的任务，每个任务被称为一个线程。在Java、C#...
C++ 多线程基础及 C++11 多线程库总结
生命在于折腾！
10-22 3539
1. 多线程基础 1.1 进程与线程 根本区别： 进程是操作系统资源分配的基本单位，线程是任务调度和执行的基本单位 开销方面： 每个进程都有自己独立的代码和数据空间，程序之间的切换开销较大。 线程可以看作是轻量级的进程，同一类线程共享代码和数据空间，每个线程都有自己独立的运行栈和程序计数器，线程之间切换开销小。 所处环境： 一个操作系统能同时运行多个进程（程序）。 在一个进程中，可以有多个线程同时执行。 内存分配方面： 系统在运行的时候会为每个进程分配不同的内存空间。 对线程而言，系统不会为
Java多线程基础知识
gldzzznb的博客
04-10 3327
这是我再次学习多线程知识的一个总结，对于刚刚接触的学习者是比较友好易懂的，便于快速的理解和掌握。
Java多线程基础（一）
计蒙不吃鱼的博客
07-19 5838
文章分两份，第一份主要内容为1-4点 1.多线程的概念 2.Java程序运行原理 3.实现多线程的2种方式 4.2种方式的区别 5.线程同步（同步锁） 6.同步线程之间的通讯 1.多线程的概念 （1）并发和并行 并行：多个CPU实例或是多台机器同时执行一段处理逻辑，是真正的同时。 并发：通过CUP调度算法，让用户看上去同时去执行，实际上从CPU操作层面并不是真正的同时。并发往往需要公共的资源，...
Qt 多线程基础及线程使用方式
热门推荐
weixin_49730048的博客
10-15 3万+
文章目录Qt 多线程操作2.线程类QThread3.多线程使用：方式一4.多线程使用：方式二5.Qt 线程池的使用 Qt 多线程操作 应用程序在某些情况下需要处理比较复杂的逻辑， 如果只有一个线程去处理，就会导致窗口卡顿，无法处理用户的相关操作。这种情况下就需要使用多线程，其中一个线程处理窗口事件，其他线程进行逻辑运算，多个线程各司其职，不仅可以提高用户体验还可以提升程序的执行效率。 Qt中使用多线程需要注意： Qt的默认线程为窗口线程（主线程）：负责窗口事件处理或窗口控件数据的更新； 子线程负责后台的业
EduCoder Java高级特性 - 多线程基础（3）线程同步
知足且上进，温柔而坚定
03-07 1万+
第1关：并发编程的三个概念 第2关：使用synchronized关键字同步线程 第3关：使用线程锁（Lock）实现线程同步，使用sleep（）函数解决了第三关线程随机导致的需要评测多次问题 第3关：使用线程锁（Lock）实现线程同步
头歌Educoder——Java高级特性 - 多线程基础（3）线程同步
赵士杰——成功并非一蹴而就，而是在持之以恒的努力中逐渐实现。
03-24 7754
文章目录第1关：并发编程的三个概念任务描述相关知识1.原子性2.可见性3.有序性编程要求题第2关：使用synchronized关键字同步线程任务描述相关知识并发编程什么时候会出现安全问题如何解决线程安全问题synchronized关键字synchronized代码块编程要求测试说明代码示例第3关：使用线程锁（Lock）实现线程同步任务描述2相关知识Lock接口lock()方法的正确使用编程要求代码示例第4关：使用volatile实现变量的可见性任务描述相关知识什么是 volatile 关键字volatile
Java多线程基础
m0_62946761的博客
05-17 3170
Java多线程基础知识
JAVA多线程基础
weixin_47600732的博客
03-19 4107
JAVA多线程基础 1.什么是并发原理？ 多线程：多线程允许我们“同时”执行多段代码。 线程是并发运行的，线程调度会统一规划CPU时间，将CPU的时间划分为若干片段，然后尽可能的均匀分配给所要并发运行的线程，每个线程在获取CPU时间片段后CPU就会运行它的任务，当时间片段用完后，Cpu会离开并执行获取到CPu时间片的线程，所以，所有线程并非真正的“同时”运行着代码，而是走走停停，这种微观上走走停停，在宏观上感觉是同步进行的现象称为“并发运行”。 2.创建线程Thread 1. 方式一：继承Thread并重写
EduCoder Java高级特性 - 多线程基础（1）使用线程
知足且上进，温柔而坚定
02-28 1万+
第1关：创建线程 任务描述 本关任务：创建一个Java线程执行特定任务。 编程要求 请仔细阅读右侧代码，根据方法内的提示，在Begin - End区域内进行代码补充，具体任务如下： 使用继承Thread类的方式创建一个名为 ThreadClassOne 的类，重写的run方法需要实现输出0-10之间的奇数，输出结果如下： 1 3 5 7 9； 使用实现Runnable接口的方式创建一个名为ThreadClassTwo的类，重写run方法，编写start方法，run方法需要实现打印0-
多线程基础与基于多线程的简单聊天室
06-24
本压缩包“多线程基础与基于多线程的简单聊天室”提供了对多线程技术的实践理解和二次开发的基础。以下是关于这个主题的详细知识点： 1. **多线程的概念**：多线程是指在一个程序中同时执行多个不同的线程，每个...
C#多线程基础知识汇总
12-17
【C#多线程基础知识汇总】 在编程领域，多线程是提高程序执行效率和并发能力的重要技术。本文将深入探讨C#中的多线程基础知识，帮助开发者理解如何在应用程序中实现并行处理。 一、什么是线程 线程是操作系统分配...
多线程基础知识
03-01
通过学习和掌握这些多线程基础知识，开发者能够编写出更加高效、稳定的并发程序，提升软件系统的性能和用户体验。同时，对多线程深入理解也有助于应对面试中的技术考察，为职业生涯的晋升铺平道路。
C++ - 函数重载
jiaowenjie的专栏
08-06 297
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
时光不等人：java每日一练
m0_67187271的博客
08-05 1065
时光悄然流逝，不等人。技术亦不会自来门前，唯有勤奋学习，方能抓住时代的脉搏。
Java面试篇（JVM相关专题）
最新发布
聂可以的博客
08-09 2103
Java面试篇（JVM相关专题）
Spring事务
c1tenj2的博客
08-07 401
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值