六种线程状态demo演示

最新推荐文章于 2022-12-10 15:45:58 发布
最新推荐文章于 2022-12-10 15:45:58 发布
阅读量151 收藏 1
点赞数 1
分类专栏： javaSE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45642975/article/details/115699290
版权

线程状态

new:线程尚未启动的状态

package cn.lizemin.demo.thread;

/**
 * @author: lizemin
 * @version: 1.0
 * 研究的是新建线程的状态
 * 新建状态：至今还未启动的线程处于这一状态
 */
public class ThreadState01 {
    //这是一个main方法,是程序的入口
    public static void main(String[] args) {
        //创建线程对象
        MyThread01 my = new MyThread01();
        System.out.println("此时的线程状态："+my.getState());
        //调用run方法，非启动线程
        my.run();
        System.out.println("此时的线程状态："+my.getState());
        //启动线程
        my.start();
        System.out.println("此时的线程状态："+my.getState());



    }

}


package cn.lizemin.demo.thread;

/**
 * @author: lizemin
 * @version: 1.0
 */
public class MyThread01 extends Thread{
    /**线程执行的代码*/
    @Override
    public void run() {
        System.out.println("小猫爱吃鱼");
    }
}

runnable:可运行的状态

这里的可运行的状态，包括正在执行，或者正在等待，比如等待获取CPU的执行权，或者等待I/O，都属于可运行状态，这个要和进程的状态区分开来。

package cn.lizemin.demo.thread;

/**
 * @author: lizemin
 * @version: 1.0
 */
public class Demo02 {
    //这是一个main方法,是程序的入口
    public static void main(String[] args) {
        //创建线程对象
        MyThread02 my = new MyThread02();
        System.out.println("此时的线程状态："+my.getState());
        //启动线程
        my.start();
        System.out.println("此时的线程状态："+my.getState());


    }

}


package cn.lizemin.demo.thread;

/**
 * @author: lizemin
 * @version: 1.0
 */
public class MyThread02 extends Thread{
    /**线程执行的代码*/
    @Override
    public void run() {
        System.out.println("线程开始执行");
        System.out.println("线程开始执行具体的任务");
        long begin_time = System.currentTimeMillis();
        while (System.currentTimeMillis()-begin_time < 5000){
            //假设做了5秒钟的任务
        }
        System.out.println("线程执行完毕");

    }
}

blocked：锁阻塞的状态

在这里插入图片描述

在这里插入图片描述

线程安全

多线程卖票

package cn.lizemin.demo.thread;

/**
 * @author: lizemin
 * @version: 1.0
 */

/**
 * 模拟买票操作
 * 假设一场电影有100张票
 * 3个窗口同时卖票
 *
 * 窗口   线程对象
 * 卖票   线程任务    实现runnable接口
 */
public class Demo03 {
    //这是一个main方法,是程序的入口
    public static void main(String[] args) {
        //创建卖票对象
        Ticket ticket = new Ticket();

        //创建3个窗口
        Thread t1 = new Thread(ticket, "窗口1");
        Thread t2 = new Thread(ticket, "窗口2");
        Thread t3 = new Thread(ticket, "窗口3");

        //开始卖票
        t1.start();
        t2.start();
        t3.start();

    }

}


package cn.lizemin.demo.thread;

/**
 * @author: lizemin
 * @version: 1.0
 */
public class Ticket implements Runnable{
    int ticket_num = 100;
    @Override
    public void run() {
        while (true){//卖票窗口永远开启
            if (ticket_num > 0){
                //模拟出票时间
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                String name = Thread.currentThread().getName();
                System.out.println(name+"正在卖第"+ticket_num--+"张票");

            }

        }

    }
}

结果是出现了重复的票，而且还会出现负数的票。

出现负数的票

原因：
ticket_num–分为2个部分，

  1. 先参与运算
  2. 然后再–

有可能前面一个线程还没来得及进行–操作，票数没有更新。后一个线程这时候也打印了num。这就是出现重复票的原因。

出现负数的票

因为第一个线程将票数改成0的时候，另外两个线程已经进来了，然后顺势将票数改成0和-1并输出。

线程同步

在这里插入图片描述

采用同步代码块实现
package cn.lizemin.demo.thread;

/**
 * @author: lizemin
 * @version: 1.0
 */

/**
 * 模拟买票操作
 * 假设一场电影有100张票
 * 3个窗口同时卖票
 *
 * 窗口   线程对象
 * 卖票   线程任务    实现runnable接口
 */
public class Demo03 {
    //这是一个main方法,是程序的入口
    public static void main(String[] args) {
        //创建卖票对象
        Ticket ticket = new Ticket();

        //创建3个窗口
        Thread t1 = new Thread(ticket, "窗口1");
        Thread t2 = new Thread(ticket, "窗口2");
        Thread t3 = new Thread(ticket, "窗口3");

        //开始卖票
        t1.start();
        t2.start();
        t3.start();

    }

}


package cn.lizemin.demo.thread;

/**
 * @author: lizemin
 * @version: 1.0
 */
public class Ticket implements Runnable{
    int ticket_num = 100;
    Object object = new Object();
    @Override
    public void run() {
        while (true){//卖票窗口永远开启
            synchronized (object){
                if (ticket_num > 0){
                    //模拟出票时间
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    String name = Thread.currentThread().getName();
                    System.out.println(name+"正在卖第"+ticket_num--+"张票");

                }
            }


        }

    }
}

获取block状态

多个线程争夺同一个锁，没有抢到锁的那个线程会进入到阻塞状态，即block.
线程A

package cn.lizemin.demo.thread.blocked;

/**
 * @author: lizemin
 * @version: 1.0
 */
public class A extends Thread{
    private Object obj;
    public A(String name,Object obj){
        super(name);
        this.obj = obj;
    }
    @Override
    public void run() {
        synchronized (obj){
            System.out.println("线程开始执行");
            System.out.println("线程A开始执行代码了");
            long begin_time = System.currentTimeMillis();
            while (System.currentTimeMillis() - begin_time < 5000){
                //模拟5秒钟的任务

            }
            System.out.println("线程A执行完毕");
        }

    }
}

线程B

package cn.lizemin.demo.thread.blocked;

/**
 * @author: lizemin
 * @version: 1.0
 */
public class B extends Thread{
    private Object obj;
    public B(String name,Object obj){
        super(name);
        this.obj = obj;
    }
    @Override
    public void run() {
        synchronized (obj){
            System.out.println("线程开始执行");
            System.out.println("线程B开始执行代码了");
            long begin_time = System.currentTimeMillis();
            while (System.currentTimeMillis() - begin_time < 5000){
                //模拟5秒钟的任务

            }
            System.out.println("线程B执行完毕");

        }

    }
}

BlockedDemo

package cn.lizemin.demo.thread.blocked;

/**
 * @author: lizemin
 * @version: 1.0
 */
public class BlockedDemo {
    //这是一个main方法,是程序的入口
    public static void main(String[] args) throws InterruptedException {
        //创建一个锁对象
        Object o = new Object();
        //创建线程
        A a = new A("小强", o);
        B b = new B("旺财", o);

        a.start();
        b.start();

        Thread.sleep(3000);
        System.out.println("此时线程A的状态："+a.getState());
        System.out.println("此时线程B的状态："+b.getState());



    }

}

最终可以看到
此时线程A的状态：RUNNABLE
此时线程B的状态：BLOCKED
线程B进入阻塞状态

timed waiting:计时等待

比如，thread.sleep(1000)在这里插入图片描述在这里插入图片描述
demo演示

package cn.lizemin.demo.thread.timed_waiting;

/**
 * @author: lizemin
 * @version: 1.0
 */
public class MyThread extends Thread{
    //这是一个main方法,是程序的入口
    public static void main(String[] args) throws InterruptedException {
        MyThread mt = new MyThread();
        mt.start();
        for (int i = 0; i < 10; i++) {
            Thread.sleep(500);
            System.out.println("线程mt的状态为："+mt.getState());
        }
    }
    //实现一个计数器，0~99计数，在每个数字之间暂停1秒，每隔10个数字输出一个字符串
    @Override
    public void run() {
        for (int i = 1; i < 99; i++) {
            if (i % 10 == 0){
                System.out.println("小猫爱吃鱼"+i);
            }
            System.out.println(i);
            try {
                /*休息1s*/
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        for (int i = 1; i < 99; i++) {


        }
    }
}

在这里插入图片描述

无限等待：waiting

使当前线程进入无限等待状态，直到其他线程唤醒它，通过notify或者

在这里插入图片描述

package cn.lizemin.demo.thread.waiting;

/**
 * @author: lizemin
 * @version: 1.0
 */
public class WaitingDemo {
    private static Object obj = new Object();
    //这是一个main方法,是程序的入口
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread() {
            @Override
            public void run() {
                synchronized (obj){
                    System.out.println("获取到锁，调用wait方法，当前线程进入无限等待，等待着别人来唤醒它");
                    try {
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("唤醒了这个线程，就不再是无限等待了，线程执行完毕");
            }
        };
        t.start();
        //创建一个线程对象唤醒前面的线程
        new Thread(){
            @Override
            public void run() {
                synchronized (obj){
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("获取到锁，执行唤醒操作");
                    obj.notify();
                }
            }
        }.start();
        Thread.sleep(3000);
        //waiting
        System.out.println("查看线程t的状态："+t.getState());



    }
}

在这里插入图片描述

terminated：被终止的状态

在这里插入图片描述

参考资料

探究Java线程状态及转换

天空的颜色_2号
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程 线程状态原理详解
08-25
以下是一个简单的示例，演示了线程状态的切换： ```java public class Demo2 { public static void main(String[] args) throws Exception { // 第一种状态切换：新建 -> 运行 -> 终止 Thread thread1 = new ...
Java之多线程(6个demo)
nuist_NJUPT的博客
08-06 3494
本文主要介绍Java中多线程，在Java中启动多线程的方法包括：继承Thread类或者实现Runnable接口，介绍了设置线程名称，设置线程优先级，设置守护线程等，介绍了线程同步，使用synchronized关键字和lock锁分别实现线程同步，解决线程安全问题，介绍了生产者和消费者模式，涉及线程延迟，等待，唤醒的方法。...
【并发编程】多线程先执行完的先取结果的解决方案：CompletionService
qq_35436158的博客
02-20 732
多线程一边生成任务,一边获取任务的返回值，让等待时间短的线程优先返回结果，这就是CompletionService。
一个demo让你彻底理解线程池工作流程
热门推荐
成都彭于晏
12-01 3万+
线程池这么用，老板见了都要激动地拍打轮椅
简单实现多线程的Demo
xiaoheihai666的博客
12-10 424
/ 最大线程数 非核心线程数=最大线程池数-核心线程池数。// 非核心线程池最大空闲时间单位。// 非核心线程池最大空闲时间。
线程的Demo
weixin_41640070的博客
04-12 268
线程1.解释Semaphore可控制资源的同时访问的个数 下面的Demo中申明了一个只有5个许可的Semaphore，而有20个线程要访问这个资源，通过acquire()和release()获取和释放访问许可。2.代码如下package com.test;import java.util.concurrent.ExecutorService;import java.util.concurrent....
springboot多线程demo
05-14
本项目"springboot多线程demo"显然是一个示例，用于演示如何在Spring Boot应用中实现和管理多线程。 1. **多线程基础** - **并发编程**：多线程是并发编程的一种方式，它允许多个任务在同一时间执行，从而提高程序...
性能之多线程-演示Demo
07-28
综上所述，“性能之多线程-演示Demo”这个主题涵盖了多线程的基础概念、使用技巧、性能优化等多个方面。通过深入研究“trunk”中的代码，开发者可以更好地理解多线程在实际应用中的工作原理，并能应用于自己的项目中...
Delphi 多线程 DEMO
09-21
这个"Delphi 多线程 DEMO"是一个实践示例，用于演示如何在Delphi中创建和管理多线程。 在描述中提到的"简单的多线程DEMO"很可能包含了以下关键知识点： 1. **线程基础**：线程是操作系统分配CPU时间的基本单元，一...
isf.zip_DEMO_进程与线程
09-21
【描述】中的“免费甘特图Gantt控件”表明，这个DEMO可能涉及到项目管理领域，甘特图是一种常见的时间线表示法，用于可视化任务的开始、结束时间和依赖关系。VB中的Gantt控件可能允许开发者创建这样的图表，以便更好...
多线程demo
01-26
简单的多线程小demo，帮助你快速理解多线程的原理和使用。
java多线程代码demo
03-19
这些java的代码demo，是本人几篇多线程文章的实例代码 http://www.cnblogs.com/yaoxiaowen/p/6576779.html
单任务多线程多断点下载Demo
08-28
改改就可以放到项目中使用，实现原理：一个数据库，两张表，一张存下载任务，一张存当前任务下载数据；多条线程同时下载一个任务，下载中断时，将以下载的数据大小存入数据库，网络恢复时，自动查询数据库中是否存在未下载完成任务，有就下载，没有就查询任务表执行下一个下载任务; 有必要的话 自己来建一个下载任务表；希望对大家有帮助！
线程的各种使用方式Demo
09-06
本Demo演示了线程的使用，包含了常用的所有使用方式。
简单的java线程demo
08-17
简单的java线程demo
线程Demo演示
weixin_33725126的博客
07-21 85
主线程执行委托Demo： 1..无委托执行线程 private void button1_Click(object sender, EventArgs e) { Thread th1 = new Thread(new ThreadStart(mtd)); th1.Start(); } private void mtd...
java多线程Demo
03-29
自己写的一些多线程的小Demo，在这里与大家分享一下。
多线程Demo
11-27
多线程演示Demo。几行代码让你了解多线程原理。
轻量级java多线程池demo
01-08
线程可相互通信，可任意调度任务，类似Akka的Actor。如果内容对您有帮助，微信扫描下方的二维码支持下作者，谢谢！
java线程的六种状态
最新发布
07-14
Java线程有以下六种状态： 1. 新建（New）：当线程对象被创建但还没有调用start()方法时，线程处于新建状态。 2. 运行（Runnable）：线程调用start()方法后，线程进入运行状态。在运行状态下，线程可能正在执行，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值