多线程 - 线程状态

最新推荐文章于 2024-10-17 19:11:48 发布
最新推荐文章于 2024-10-17 19:11:48 发布
阅读量74 收藏
点赞数 2
文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44943937/article/details/118521490
版权

线程状态

创建，就绪，运行，阻塞，死亡。

线程五大状态

在这里插入图片描述

线程结束 stop()

  • 不推荐使用JDK提空的 stop，destroy 方法来结束线程。
  • 推荐线程自己停下来
  • 建议使用一个标志位进行终止标量，如当 flag = false 时结束线程。
public class ThreadTest01 implements Runnable {
    //1 定义线程结束的标识
    private boolean flag = true;

    @Override
    public void run() {
        //2 线程使用该标识
        while (flag){
            System.out.println("方法体");
        }
    }

    //3 结束线程的方法
    public void threadStop( ) {
        this.flag = false;
    }


    public static void main(String[] args) {
        ThreadTest01 threadTest01 = new ThreadTest01();
        new Thread(threadTest01).start();
        for (int i = 0; i < 1000; i++) {
            if (i >= 900){
                threadTest01.threadStop();
            }
            System.out.println("main : " + i);
        }
    }
}

线程休眠 sleep()

  • 线程休眠
    1. sleep（时间） 指定线程休眠多长时间（毫秒）；
    2. sleep 存在异常，需要抛出。
    3. sleep 时间到了后线程进入就绪状态。
    4. sleep 可以模拟网络延迟 ，倒计时等。
    5. 每一个队形斗鱼一个锁，sleep 不会释放锁。
// 模拟网络延时
public class ThreadTest02   {
    
    public static void main(String[] args) throws InterruptedException {
        toTimeDown();
    }

    public static void toTimeDown() throws InterruptedException {
        int num = 10;
        while (true){
            Thread.sleep(1000);
            System.out.println(num--);
            if (num<=0){
                break;
            }
        }
    }
}

线程礼让 yield()

  • 礼让线程，让当前的正在执行的线程暂停，但不会阻塞。
  • 将线程从运行状态转为就绪状态
  • 让 CPU 重新调度，礼让不一定会成功。由cpu决定
public class ThreadTest03 {

    public static void main(String[] args) throws InterruptedException {
        myYield myYield = new myYield();
        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();
    }
}
class myYield implements  Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始");
        // 线程礼让
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程结束");
    }
}

礼让就是 重新 竞争线程。

线程插队 join()

  • join 合并线程，待此线程执行完成后，再执行其他线程。
  • 也就是说，阻塞其他的所有线程，所以其实应该是插队线程。
  • join 的最重要的部分，就是插队可以保证，这个线程自己一定会先执行完，这是在很多地方需要的逻辑。
public class JoinDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            for (int i=0; i<100; i++){
                System.out.println("myThread is joining" + i);
            }
        });

        t.start();

        for (int i=0; i<100; i++){
            if (i == 50){
                t.join();//插队，此时主线程不能执行，而要执行 t
            }
            System.out.println("main is running" + i);
        }
    }
}

线程等待 wait()

注意事项

  1. 当前线程调用共享对象的wait()方法时，当前线程只会释放当前共享对象的锁，当前线程持有的其他共享对象的监视器锁并不会被释放,就会造成死锁
  2. 可以传递int参数里决定等待几秒
  3. 不会释放锁
    private static  Object Lipstick = new Object();
    private static  Object Mirror = new Object();

    public static class Lipstick implements Runnable {

        @Override
        public void run() {

            try{

                // 获取Lipstick的共享资源监视器锁
                synchronized (Lipstick) {
                    System.out.println("获取线程A中Lipstick的锁");
                    // 获取Mirror的共享资源的监视器锁
                    synchronized (Mirror) {
                        System.out.println("获取线程A中Mirror的锁");

                        // 线程A阻塞，并释放获取到的Lipstick的锁
                        System.out.println("将线程A挂起，并释放Lipstick的锁");
                        Lipstick.wait();
                    }
                }
            } catch(InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static class Mirror implements Runnable {

        @Override
        public void run() {

            try{
            	// 休眠1s
                Thread.sleep(1000);

                // 获取Lipstick的共享资源监视器锁
                synchronized (Lipstick) {
                    System.out.println("获取线程B中Lipstick的锁");

                    System.out.println("获取线程B中Mirror的锁");

                    // 获取Mirror的共享资源的监视器锁
                    synchronized (Mirror) {
                        System.out.println("获取线程B中Mirror的锁...");

                        // 线程B阻塞，并释放获取到的Lipstick的锁
                        System.out.println("获取线程B中Mirror的锁...");
                        Lipstick.wait();
                    }
                }
            } catch(InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {

       Thread a = new Thread(new Lipstick());
       Thread b = new Thread(new Mirror());

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

       a.join();
       b.join();
    }

线程唤醒 notifyAll()

唤醒所有等待的线程。

一般和wait 搭配使用

  Father father = new Father();
  Thread thread = new Thread(father);
  thread.notifyAll();

线程的优先级

Java中线程优先级用1~10来表示，分为三个级别：

  • 低优先级：1~4，其中类变量Thread.MIN_PRORITY最低，数值为1；
  • 默认优先级：如果一个线程没有指定优先级，默认优先级为5，由类变量Thread.NORM_PRORITY表示；
  • 高优先级：6~10，类变量Thread.MAX_PRORITY最高，数值为10。

最终执行的还是由CPU来决定，只是优先级高的先执行的几率大了。

优先级低只是意味着获取的调度的概率低，并不是优先级低的就不会被提前调用，这都要看CPU的调度。

//测试线程的优先级
public class TestPriority extends Thread {
    public static void main(String[] args) {
        //主线程优先级
        System.out.println(Thread.currentThread().getName()+
                "--》"+Thread.currentThread().getPriority());
        MyPriorty myPriorty = new MyPriorty();
        Thread t1 = new Thread(myPriorty);
        Thread t2 = new Thread(myPriorty);
        Thread t3 = new Thread(myPriorty);
        Thread t4 = new Thread(myPriorty);
        Thread t5 = new Thread(myPriorty);
        //默认优先级
        t1.start();
        //最小的 
        t2.setPriority(Thread.MIN_PRIORITY);
        t2.start();
        //最大的
        t3.setPriority(Thread.MAX_PRIORITY);
        t3.start();
		//小于0或者大于10 会出现异常
        t4.setPriority(-1);
        t4.start();

        t5.setPriority(7);
        t5.start();
    }
}

class MyPriorty implements Runnable{

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

守护线程

  • 线程分 用户线程 和 守护线程
  • 虚拟机必须确保用户线程执行完毕
  • 虚拟机不用等待守护线程执行完毕
  • 如，后台记录日志，监控内存，GC等。。
//测试守护线程
//父亲保护你
public class TestDemo01 {
    public static void main(String[] args) {
        Father father = new Father();
        You you = new You();

        Thread thread = new Thread(father);
        //设置为守护线程，不会停止 ,默认为false 用户 线程
        thread.setDaemon(true);
        thread.start();

        new Thread(you).start();//用户线程
    }

}

//父亲
class  Father implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("父亲保护着你");
        }
    }
}

class  You implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("每天开心的活着");
        }
        System.out.println("GoodBye World!");
    }
}
MaybShmily
关注
多线程之线程状态
qq_51993933的博客
06-24 3135
## 线程状态 五大状态 1.创建状态：Thread thread = new Thread(); 线程对象一旦创建就进入了新生状态。 2.就绪状态：当调用start()方法时，进入就绪状态，但不代表立即调度执行（等待cpu调度）。 3.运行状态或同态：进入运行状态，线程才真正执行线程体的代码块。 4. 阻塞状态：当调用sleep,wait或同步锁定时，线程进入阻塞状态，就是代码不往下执行，阻塞解除后进入就绪状态，等待cpu调度。 5.死亡状态：线程中断或者结束，进入死亡状态，不能再次启动。 停止线程
Java多线程 - 线程状态
honvin的博客
09-21 6260
线程状态 五个状态：新生、就绪、运行、死亡、阻塞 停止线程 不推荐使用JDK提供的stop()、destroy()方法【已弃用】 推荐线程自己停止 建议用一个标志位进行终止变量，到flag=false，则终止线程运行 public class StopDemo implements Runnable { // 设置一个标志位 boolean flag = true; @Override public void run() { // 线程体使用该标志
C#高级--多线程详解
李宥的博客
10-03 5万+
C#高级–多线程详解 零、文章目录 一、什么是多线程 1、进程 当一个程序开始运行时，它就是一个进程，进程包括运行中的程序和程序所使用到的内存和系统资源。 而一个进程又是由多个线程所组成的。 2、线程 线程是程序中的一个执行流，每个线程都有自己的专有寄存器(栈指针、程序计数器等)，但代码区是共享的，即不同的线程可以执行同样的函数。 3、句柄 句柄是Windows系统中对象或实例的标识，这些对象包括模块、应用程序实例、窗口、控制、位图、GDI对象、资源、文件等。 4、多线程 （1）多线程概念 多线程是指程序中
多线程-共享全局变量问题
Devin12345的博客
08-08 3266
文章目录多线程-共享全局变量问题多线程可能遇到的问题同步计算错误的结果互斥锁死锁 多线程-共享全局变量问题 多线程可能遇到的问题 假设有两个线程t1和t2，都要对一个变量g_num进行运算(+1)，两个进程t1和t2分别对g_num各加10次，g_num的最终结果？ import threading import time g_num=0 def work1(num): global g...
多线程-线程之间的通信
weixin_45737870的博客
10-17 5766
1、为什么需要线程通信 线程是操作系统调度的最小单位，有自己的栈空间，可以按照既定的代码逐步的执行，但是如果每个线程间都孤立的运行，那就会造资源浪费。所以在现实中，我们需要这些线程间可以按照指定的规则共同完成一件任务，所以这些线程之间就需要互相协调，这个过程被称为线程的通信。 线程的通信可以被定义为： 线程通信就是当多个线程共同操作共享的资源时，互相告知自己的状态以避免资源争夺。 2、线程通信的方式 线程通信主要可以分为三种方式，分别为共享内存、消息传递和管道流。每种方式有不同的方法来实现。 共享内存：线
Java多线程--AQS的原理
IT利刃出鞘的博客
11-04 4364
本文介绍Java中的AQS的原理。 Java的AQS是JDK自带的锁机制，是JUC（java.util.concurrent）的基础，很多并发类都是基于它实现的，例如：ReentrantLock、CountDownLatch、Semaphore、ReadWriteLock，CyclicBarrier。
多线程--线程的六种状态
m0_58430482的博客
04-21 1929
多线程--线程的状态
一文详解C++多线程
热门推荐
非晚非晚的博客
04-25 8万+
传统的C++（C++11之前）中并没有引入线程这个概念，在C++11出来之前，如果我们想要在C++中实现多线程，需要借助操作系统平台提供的API，比如Linux的，或者windows下的 。C++11提供了语言层面上的多线程，包含在头文件中。它解决了跨平台的问题，提供了管理线程、保护共享数据、线程间同步操作、原子操作等类。C++11 新标准中引入了5个头文件来支持多线程编程，如下图所示：
autojs之多线程-Threads
头发浓密的萌新的博客
07-17 9075
autojs多线程新手入门 autojs多线程新手入门前言一、多线程使用须知二、个人理解1.引入库2.读入数据总结 autojs之多线程-Threads 前言 我也是初初接触多线程，对于小白来说，可能会觉得无从下手，我刚开始也是毫无头绪，对一些奇奇怪怪的问题搞不明白，比如： 在这里，我就从一个小白的角度，说明一下多线程到底怎么用， 若有错误，感谢指出 一、多线程使用须知 threads模块提供了多线程支持，可以启动新线程来运行脚本。 脚本主线程会等待所有子线程执行完成后才停止执行，因此如果子线程中有
java多线程-- thread.getState() 查看线程状态
qq_43619461的博客
10-23 2304
package cn.usts.edu.lesson06; /** * 一个线程可以在给定时间点处于一个状态。 这些状态是不反映任何操作系统线程状态的虚拟机状态。 * * 线程状态。 线程可以处于以下状态之一： * NEW 尚未启动的线程处于此状态。 * RUNNABLE 在Java虚拟机中执行的线程处于此状态。 * BLOCKED 被阻塞等待监视器锁定的线程处于此状态。 * WAITING 正在等待另一个线程..
vc++ multithread多线程教程---线程通信--利用事件对象,线程同步--使用信号量,线程同步--使用互斥量,线程同步--使用临界区
04-04
在VC++编程环境中，多线程技术是一种提升程序性能的重要手段。它允许程序同时执行多个任务，从而提高CPU利用率和程序响应速度。然而，多线程编程也带来了数据同步和线程通信的问题，以防止数据冲突和竞态条件。本...
深入分析JAVA 多线程--interrupt()和线程终止方式
08-19
JAVA 多线程 interrupt() 和线程终止方式 JAVA 多线程中，interrupt() 和线程终止方式是两个非常重要的概念。本文将深入分析 JAVA 多线程中 interrupt() 和线程终止方式的相关知识。 一、interrupt() 介绍 ...
OC-多线程-上下文切换
08-02
在iOS开发中，多线程是一项关键的技术，用于提高应用程序的响应速度和用户体验。当我们谈论“OC-多线程-上下文切换”时，我们实际上是在讨论Objective-C中多线程环境下的一个核心概念。上下文切换是操作系统调度线程...
【IT十八掌徐培成】Java基础第09天-004.多线程-状态机变换.zip
08-07
在IT领域，多线程是Java编程中一个重要的概念，特别是在设计高性能、高并发的应用时。本课程由知名IT讲师徐培成主讲，聚焦Java基础的第09天，主题为“多线程状态机变换”。通过学习这部分内容，开发者能够深入理解...
【C++刷题】力扣-#121-买卖股票的最佳时机
会写代码的饭桶
10-16 289
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
java 异常包装
最新发布
fdvvg的博客
10-17 207
通过异常包装，可以在Java中有效地处理和传递异常。这样做不仅能保持原始异常的信息，还能为上层调用者提供更多的上下文信息。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 346
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Java安卓开发之Fragment开发（通俗易懂版）——第8章
一个脚本小子的博客
10-13 667
FragmentManager中的getSupportFragmentManager()方法不支持Activity，不论是旧版的FragmentManager还是新版的，因此我们要把继承Activity类改成继承AppCompatActivity类。
JavaWeb合集05-SpringBoot基础知识
qq_57340195的博客
10-17 511
Autowrite ：自动装配，通过声明的数据类型来装配对应的bean对象。缺点，只能获取到一个相同类型的bean对象，如果有IOC容器里面有2个Bean对象，使用@Autowrite依赖注入就好报错。由于三层架构中，每一层都需要下次成来提供对应的方法，所有要new 下一次的对象，如果上一层的类名发送改变，那么上一层就需要修改对应的类名，如下。3、@Resource注解：通过它来代替@Autowrite注解，直接指定要注入的Bean对象，参数name的值就是要注入的Bean对象。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值