java线程状态和线程调度

最新推荐文章于 2024-03-27 04:47:54 发布
最新推荐文章于 2024-03-27 04:47:54 发布
阅读量412 收藏
点赞数 1
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45671732/article/details/119053773
版权

java线程的创建和启动

文章目录

多线程

线程的状态

Java 线程状态、线程池状态_shadow_zed的博客-CSDN博客_java 线程池的状态

package Threads;

public class MyThread5 implements Runnable {
    @Override
    public void run() {
        System.out.println("线程正在运行，处于运行状态");
        try {
            System.out.println("线程开始休眠，处于阻塞状态");
            //线程休眠5S
            Thread.sleep(5000);
            System.out.println("线程休眠结束，阻塞状态结束，再次进入就绪状态");
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("线程中断");
        }
    }
}

package Test;

import Threads.MyThread5;

//测试线程的状态
public class MyThread5Test {
    public static void main(String[] args) {
        Runnable runnable = new MyThread5();
        Thread t = new Thread(runnable);
        System.out.println("线程处于创建状态");
        t.start();
        System.out.println("线程处于就绪状态");
    }
}

线程调度

线程优先级

由于线程之间的运行是通过抢占CPU的资源来进行的，线程调度指的是按照特定的机制为多个线程分配CPU的使用权。
请添加图片描述

线程的优先级由1-10表示，1表示最低，10最高，默认的优先级是5。优先级高的线程获得CPU的资源概率比较大.

尝试更改线程的优先级:

package Threads;

//创建线程类，实现Runnable接口
public class MyThread2 implements Runnable {
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}

package Test;

import Threads.MyThread2;

//测试线程
public class MyThread2Test {
    public static void main(String[] args) {
        //创建线程对象
        Runnable runnable = new MyThread2();
        Thread thread = new Thread(runnable, "mythread1");
        Thread thread1 = new Thread(runnable, "mythread2");
        //线程调度，设置线程优先级
//        thread1.setPriority(10);
//        thread.setPriority(1);
        thread1.setPriority(Thread.MAX_PRIORITY);
        thread.setPriority(Thread.MIN_PRIORITY);
        //启动线程
        thread.start();
        thread1.start();
    }
}
线程休眠

线程调度的另一个方案是线程休眠。让线程展示睡眠指定的时长，线程会进入到阻塞状态，睡眠时间过后的线程会再进入可运行的状态。

方法是:

public static void sleep(long millis)

millis是休眠时长，以毫秒为单位，调用sleep()方法需要处理InterruptedException异常。

package Threads;

//模拟线程休眠的过程
public class Wait {
    public static void bySec(long s) {
        for (int i = 1; i <= 5; i++) {
            System.out.println(i+"秒");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        System.out.println("线程开始休眠");
        Wait.bySec(5);
        System.out.println("线程结束休眠");
    }
}
阻塞线程
  • join()方法
    等待该线程终止，等待加入的其他线程结束后在继续执行本线程
package Threads;

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

package Test;


import Threads.MyThread6;

public class MyThread6Test {
    public static void main(String[] args) {
        //创建子线程对象t
        Runnable runnable = new MyThread6();
        Thread t = new Thread(runnable, "myThread");
        t.start();
        //主线程main做的事情
        for (int i = 1; i <= 20; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
            //当i = 5的时候，强制把t线程加入执行
            //线程调度:join()--等待线程终止，等待t线程执行结束后，main主线程再继续执行
            if (i == 5) {
                try {
                    t.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
线程礼让
  • yield()方法

暂停当前线程，允许其他具有相同优先级的线程获得运行机会，该线程处于就绪状态，不会转为阻塞状态。这是线程之间的礼让问题，只是提供一种可能，但是不能保证一定会礼让成功。

package Threads;

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

package Test;


import Threads.MyThread7;

public class MyThread7Test {
    public static void main(String[] args) {
        Runnable runnable = new MyThread7();
        Thread t1 = new Thread(runnable, "线程A");
        Thread t2 = new Thread(runnable, "线程B");
        t1.start();
        t2.start();
    }
}
线程调度练习
  • 优先级问题
package Threads;

public class MyThread8 implements Runnable {
    @Override
    public void run() {

    }
}

package Test;

import Threads.MyThread8;

//获取和设置主线程和子线程的优先级
public class MyThread8Test {
    public static void main(String[] args) {
        //主线程
        Thread mainThread = Thread.currentThread();
        //子线程
        Thread myThread = new Thread(new MyThread8());
        System.out.println("默认的优先级");
        System.out.println("主线程名:" + mainThread.getName() + "优先级:" + mainThread.getPriority());
        System.out.println("子线程名:" + myThread.getName() + "优先级:" + myThread.getPriority());
        System.out.println("修改优先级后");
        mainThread.setPriority(Thread.MAX_PRIORITY);
        myThread.setPriority(Thread.MIN_PRIORITY);
        System.out.println("主线程名:" + mainThread.getName() + "优先级:" + mainThread.getPriority());
        System.out.println("子线程名:" + myThread.getName() + "优先级:" + myThread.getPriority());
    }
}

  • 练习

    需求：某一个科室一天需看普通号20个，特需号10个，特需号的看病时间是普通号的2倍。开始时普通号和特需号并行叫号，叫到特需号的概率比普通号的高。当普通号叫完第10号时，要求先看完全部的特需号再看普通号。

package Threads;

public class SpecialThread implements Runnable {
    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            System.out.println("特需号:" + i + "号病人正在看病");
            //线程休眠来表示看病的过程
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

package Threads;

//模拟医院看病
public class CommonThread {
    public static void main(String[] args) {
        //当前线程--普通号
        //创建一个特需号的线程
        Thread special = new Thread(new SpecialThread());
        special.setPriority(Thread.MAX_PRIORITY);
        special.start();
        for (int i = 1; i <= 20; i++) {
            System.out.println("普通号:" + i + "号病人在看病");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (i == 10) {
                try {
                    special.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
  • 多线程数据共享问题

多个线程共享数据时，可能会引发数据的不安全问题。

package Threads;

public class TicketThread implements Runnable {
    private int ticket = 10;//记录车票总数
    private int num = 0;//记录用户抢到了第几张票

    //用户抢票
    @Override
    public void run() {
        while (true) {
            if (ticket <= 0) {
                break;
            }
            //有余票，则抢票
            //修改车票数:总票数在抢完票后减一张
            ticket--;
            //用户抢完票后，票数加一
            num++;
            //模拟网络延迟
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //显示出票反馈给用户
            System.out.println(Thread.currentThread().getName() + "抢到了第" + num + "张票,剩余" + ticket + "张票");
        }
    }
}

package Test;

import Threads.TicketThread;

public class TicketThreadTest {
    public static void main(String[] args) {
        Runnable runnable = new TicketThread();
        Thread t1 = new Thread(runnable);
        Thread t2 = new Thread(runnable);
        Thread t3 = new Thread(runnable);
        System.out.println("各方开始抢票");
        t1.start();
        t2.start();
        t3.start();
    }
}

java线程同步

qq_45671732
关注
专栏目录
Java线程调度之线程休眠用法分析
09-03
总之，Java线程调度和线程休眠是多线程编程中不可或缺的部分，它们帮助开发者控制和协调并发执行的任务，以达到更好的系统性能和程序设计。理解这些概念并熟练运用，能够提升Java应用程序的并发处理能力和用户体验。
Thread的sleep()方法
qq_37555579的博客
08-06 2488
Thread的sleep()方法
java多线程
Coder_android
09-28 688
一个线程创建之后，总是处于其生命周期的4个状态之一中。线程的状态表明此线程当前正在进行的活动，而线程的状态是可以通过程序来进行控制的，就是说，可以对线程进行操作来改变状态。这些操作包括启动(start)、终止(stop)、睡眠(sleep)、挂起 (suspend)、恢复(resume)、等待(wait)和通知(notify)。每一个操作都对应了一个方法，这些方法是由软件包java.lang提供的
java基础-线程通信
LemonSnm的博客
12-30 1326
1、通信的方式： 要想实现多个线程之间的协同，如：线程的执行顺序、获取某个线程的执行结果等。 涉及到线程之间的通信，分为下面四类： ①文件共享 ②网络共享 ③共享变量 ④JDK提供的线程协调API：suspend/resume、wait/notify、park/unpark 1.1文件共享 线程1写数据到文件里，线程2读取文件中的数据内容，实现数据的交换 代码示例： import java.nio.file.Files; import java.nio.file.Pat..
多线程|sleep和wait的区别
Yang_ccH的博客
01-23 631
Thread.sleep(5000) 和 o.wait(5000) 有何区别？ 根本区别：语义不同 sleep： 休眠5秒，保证一定能休眠5秒； wait： 等待通知，最多等五秒，不保证一定能休眠够5秒，一旦被通知了，可以立即醒来。 表象上的区别： sleep调用，不需要持有锁； wait调用，必须持有 o 这个锁； sleep休眠过程不会释放锁； wait休眠过程，会释放锁，但只会释放 o 这个对象锁，其他持有锁不释放。 ...
Java多线程——线程的sleep方法、中断线程的睡眠
Best_Basic的博客
08-22 5557
Java多线程——线程的sleep方法、中断线程的睡眠。 sleep() 的作用是让当前线程休眠，即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。sleep()会指定休眠时间，线程休眠的时间会大于/等于该休眠时间；在线程重新被唤醒时，它会由“阻塞状态”变成“就绪状态”，从而等待cpu的调度执行。
Java线程状态变换过程代码解析
08-19
理解Java线程状态的变化对于编写并发程序至关重要，它帮助开发者预测和控制线程的行为，避免死锁、饥饿等问题。正确使用线程状态转换方法如`yield()`和`join()`，可以提高程序的并发性能和可维护性。
Java多线程 线程状态原理详解
08-25
Java多线程是并发编程中的核心概念...理解线程状态以及它们之间的转换对于调试多线程问题、优化并发性能以及避免死锁和竞态条件等并发问题至关重要。熟练掌握这些知识能帮助开发者编写出更加健壮和高效的Java并发程序。
Java多线程和并发知识整理
05-18
Java线程有新建、可运行、运行、阻塞、等待、超时等待和终止等状态。 2.2 使用方式 可以通过`Thread`类或`Runnable`接口创建线程，使用start()方法启动。 2.3 基础机制 包括线程调度、上下文切换等。 2.4 中断 线程...
Java线程状态及切换、关闭线程的正确姿势分享
08-25
"Java线程状态及切换、关闭线程的正确姿势分享" 本文将详细介绍Java线程状态及切换、关闭线程的相关内容。线程状态及切换是Java多线程编程中一个非常重要的概念，掌握线程状态及切换是编写高效、稳定、可靠的多线程...
Thread.sleep() 线程睡眠
殇莫忆的博客
10-24 8249
通俗的理解 ：        就是放在你想让线程休息的地方，比如你打印一些随机数的话，你想让它打印的速率慢一点，这个时候，你就可以在打印那个地方sleep()一下。 定义理解： Thread.Sleep()方法用于将当前线程休眠一定时间 时间单位是毫秒                                                                      ...
Java 并发基础
JILAU_WHO_AM_I_Q234的博客
10-28 925
Java并法基础
java工作复习——4大时间等待——强制等待（Thread.sleep(5000);）
小白龙白龙马的博客
04-22 363
package jkcs; import org.openqa.selenium.By; import org.openqa.selenium.WebDriver; import org.openqa.selenium.firefox.FirefoxDriver; import org.openqa.selenium.interactions.Actions; public class j...
JAVA多线程————一篇文章让你彻底征服多线程开发(一)
热门推荐
姚佳伟
06-29 3万+
线程生命周期 线程的调度与控制 synchronized 死锁 守护线程 Timerschedule线程生命周期线程是一个进程中的执行场景,一个进程可以启动多个线程 多线程不是为了提高执行速度,而是提高应用程序的使用率.线程和线程共享”堆内存和方法区内存”.栈内存是独立的,一个线程一个栈.可以给现实世界中的人类一种错觉 : 感觉多线程在同时并发执行. 很多人都对其中的一些概念不够明确，如同步、
线程的优先级、Thread.yield()、Thread.sleep(5000)
乘风晓栈的博客
02-18 764
改变线程的优先级 线程的优先级只要知道就可以了，用默认的5级就足够。 千万不要改变线程的优先级，否则若是虚拟机中垃圾回收机制被饿死了不能执行，导致虚拟机内存耗尽崩溃。
java每日练习-网络编程基础知识
Mary～fighting的博客
06-14 260
此篇博客是基于传智播客出版的《java 基础入门》一书中的第十章网络编程基础上写的代码，具体细节并未在此篇博客中出现，不懂的小伙伴可以参考原书，这里是关于哪本书中的几个程序的实现，包括UDP网络程序，简单的TCP网络程序，以及多线程的TCP网络程序，还有一个关于TCP案例–文件上传。ps:代码都是先写服务器端，再次是客户端，但UDP不分服务器端和客户端，所以分为接收端还有发送端。 1. UDP网络...
Thread.sleep()方法
CheerForU
03-15 2万+
为什么要用sleep，主要是为了暂停当前线程，把cpu片段让出给其他线程，减缓当前线程的执行。 两种方式： 第一种方式是只调用sleep静态方法；第二种是获取对象后再调用sleep静态方法。第二种方式效率要低一些，因为多了一次函数调用，而且通过对象调用静态方法也不太符合“静态”的定义（静态成员最好通过类名直接访问），但功能上是一致的。当需要调用非静态方法时使用第二种方式，否则直接使用第一种方式...
为什么不推荐使用 stop、suspend 方法中断线程？
最新发布
2401_83641634的博客
03-27 824
由于篇幅限制，小编在此截出几张知识讲解的图解由于篇幅限制，小编在此截出几张知识讲解的图解[外链图片转存中…(img-qCxIURiY-1711486069344)][外链图片转存中…(img-9l5zMWA2-1711486069345)][外链图片转存中…(img-LmlebmWk-1711486069345)][外链图片转存中…(img-nd8B2u2r-1711486069345)][外链图片转存中…(img-TEg2BOh6-1711486069345)]点击传送门，即可免费领取！
C#教程（1）-----核心C#篇
qq_43679333的博客
07-24 8929
一：C#基础 1. 变量 形式：datatype identifier 例如：int i;该语句声明了变量i，但是不能再编译器中使用这个变量i，因为你还没有对他进行初始化。 赋值：i = 0; 上述分为两句对一个变量进行了声明和赋值，还可以用一条语句对其声明并初始化他的值 int i = 10; 如果一行语句中声明了不同的变量，那么他们是同一数据类型。例如： int x = 0,y = 1;//...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

qq_45671732

你们鼓励将是我创作的最大动力！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值