多线程（中）

最新推荐文章于 2022-04-22 21:33:31 发布
最新推荐文章于 2022-04-22 21:33:31 发布
阅读量76 收藏
点赞数 1
分类专栏： 多线程详解 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44812479/article/details/120820811
版权

线程状态

  1. 线程五大状态
    在这里插入图片描述
    在这里插入图片描述
  2. 线程常用方法
方法说明
setPriority(int newPriority)更改线程的优先级
static void sleep(long millis)在指定的毫秒数内让当前正在执行的线程休眠
void join()等待该线程终止
static void yield()暂停当前正在执行的线程对象，并执行其他线程
void interrupt()中断线程，别用这个方式
boolean isAlive()测试线程是否处于活动状态

停止线程

  1. 不推荐使用JDK提供的stop()、destroy()方法
  2. 推荐线程自己停下来
  3. 建议使用一个标志位进行终止变量，当flag=false，则终止线程运行
package com.zcf.state;

//测试stop
//1.建议线程正常停止：利用次数，不建议死循环
//2.建议使用标志位：设置一个标志位
//3.不要使用stop或者destroy等JDK不建议使用的方法
public class TestStop implements Runnable{

    //1.设置一个标志位
    private boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println("run...Thread"+i++);
        }
    }

    //2.设置一个公开的方法停止线程，转换标志位
    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("main"+i);
            if(i==900){
                //调用stop方法切换标志位，让线程停止
                testStop.stop();
                System.out.println("线程该停止了");
            }
        }
    }
}

运行结果为：
在这里插入图片描述
自己定义的线程和主线程同时进行，在i=900后，自己定义的线程通过标志位执行stop方法停止，主线程则运行完1000次后自己停止

线程休眠_sleep

  1. sleep（时间）指定当前线程阻塞的毫秒数
  2. sleep存在异常InterruptedException
  3. sleep时间达到后线程进入就绪状态
  4. sleep可以模拟网络延时，倒计时等
  5. 每一个对象都有一个锁，sleep不会释放锁
  6. 模拟网络延时：
package com.zcf.state;

//模拟网络延时：放大问题的发生性
public class TestSleep implements Runnable{

    //票数
    private int ticketNums = 10;

    @Override
    public void run() {
        while(true){
            if(ticketNums<=0){
                break;
            }
            //模拟延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNums--+"票");
        }
    }

    public static void main(String[] args) {
        TestSleep testSleep = new TestSleep();
        new Thread(testSleep,"小明").start();
        new Thread(testSleep,"老师").start();
        new Thread(testSleep,"黄牛").start();
    }
}
  1. 模拟倒计时：
package com.zcf.state;

//模拟倒计时
public class TestSleep2 {

    public static void main(String[] args) {
        try {
            tenDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

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

}
  1. 每隔一秒打印一次系统时间：
package com.zcf.state;

import java.text.SimpleDateFormat;
import java.util.Date;

//每隔一秒打印一次系统时间
public class TestSleep3 {
    public static void main(String[] args) throws InterruptedException {
        Date startTime = new Date(System.currentTimeMillis());//获取系统当前时间
        while(true){
            Thread.sleep(1000);
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
            startTime = new Date(System.currentTimeMillis());//更新当前时间
        }
    }
}

线程礼让_yield

  1. 礼让线程，让当前正在执行的线程暂停，但不阻塞
  2. 将线程从运行状态转为就绪状态
  3. 让CPU重新调度，礼让不一定成功，看CPU心情
package com.zcf.state;

//测试礼让线程
//礼让不一定成功，看CPU心情
public class TestYield {
    public static void main(String[] args) {
        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

  1. join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞
  2. 可以想象成插队
package com.zcf.state;

public class TestJoin implements  Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 2; i++) {
            System.out.println("vip来了"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();

        //主线程
        for (int i = 0; i < 5; i++) {
            if(i==2){
                thread.join();
            }
            System.out.println("main"+i);
        }
    }
}

运行结果为：
在这里插入图片描述

观测线程状态

  1. Thread.State，线程状态。线程可以处于以下状态之一：

  • NEW：尚未启动的线程处于此状态

  • RUNNABLE：在java虚拟机中执行的线程处于此状态

  • BLOCKED：被阻塞等待监视器锁定的线程处于此状态

  • WAITING：正在等待另一个线程执行特定动作的线程处于此状态

  • TIMED_WAITING：正在等待另一个线程执行动作达到指定等待时间的线程处于此状态

  • TERMINATED：已退出的线程处于此状态

    一个线程可以在给定时间点处于一个状态。这些状态是不反映任何操作系统线程状态的虚拟机状态

  1. 线程死亡后不能再启动
package com.zcf.state;

public class TestState {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 1; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        //观察状态
        Thread.State state = thread.getState();
        System.out.println(state);//NEW
        //观察启动后
        thread.start();
        state =thread.getState();
        System.out.println(state);//RUNNABLE

        while(state != Thread.State.TERMINATED){
            Thread.sleep(200);//TIMED_WAITING
            state = thread.getState();
            System.out.println(state);//TERMINATED
        }
    }
}

运行结果为：
在这里插入图片描述

线程的优先级

  1. java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行
  2. 线程的优先级用数字表示，范围从1-10：
Thread.MIN_PRIORITY = 1;
Thread.MAX_PRIORITY = 10;
Thread.NORM_PRIORITY = 5;
  1. 使用以下方式改变或获取优先级：
getPriority().setPriority(int xxx)
  1. 优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了，这都是看CPU的调度
package com.zcf.state;

public class TestPriority {
    public static void main(String[] args) {
        //主线程默认优先级
        System.out.println(Thread.currentThread().getName()+"->"+Thread.currentThread().getPriority());
        MyPriority myPriority = new MyPriority();
        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4 = new Thread(myPriority);
        Thread t5 = new Thread(myPriority);
        //先设置优先级再启动
        t1.start();

        t2.setPriority(3);
        t2.start();

        t3.setPriority(Thread.MAX_PRIORITY);
        t3.start();

        t4.setPriority(Thread.MIN_PRIORITY);
        t4.start();

        t5.setPriority(Thread.NORM_PRIORITY);
        t5.start();
    }
}

class MyPriority implements Runnable{

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

运行结果为：
在这里插入图片描述
基本都会先执行优先级高的线程

守护线程

  1. 线程分为用户线程和守护线程，守护线程英文单词为daemon
  2. 虚拟机必须确保用户线程执行完毕
  3. 虚拟机不用等待守护线程执行完毕
  4. 如：后台记录操作日志，监控内存，垃圾回收等待…
package com.zcf.state;

//测试守护线程
public class TestDaemon {
    public static void main(String[] args) {
        God god = new God();
        You you = new You();

        Thread thread = new Thread(god);
        thread.setDaemon(true);//默认是false，即正常线程都是用户线程

        thread.start();//上帝守护线程启动

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

//守护线程，上帝
class God implements Runnable{

    @Override
    public void run() {
        while(true){
            System.out.println("god bless you");
        }
    }
}

//用户线程，你
class You implements  Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("开心活着");
        }
        System.out.println("goodbye world");
    }
}

运行结果为：
在这里插入图片描述
在这里插入图片描述
用户线程和守护线程同时进行，等到用户线程执行完毕之后，虚拟机关闭需要一点时间，所以守护线程又执行几次，之后用户线程和守护线程都执行完毕（即使守护线程在程序里设置的是死循环，仍然不再执行）

CRUSH-0725
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java---创建三个线程
qy_xm的博客
05-13 1057
创建3个线程，zhangsan，lisi，teacher。线程zhangsan和lisi准备休眠10秒后在输出“早上好!"teacher线程在输出三句“上课”以后，吵醒休眠的线程zhangsan，zhangsan被吵醒后再吵醒lisi package Sj2; public class Xiancheng { public static void main(String[] args) { // TODO Auto-generated method stub ClassRoom cl
线程状态
z3447643805的博客
02-21 94
线程方法 setPriority(int newPriority)：更改线程的优先级 static void sleep(long millis)：在指定的毫秒数内让当前正在执行的线程休眠 void join()：等待该线程终止 static void yield()：暂停当前正在执行的线程对象，并执行其他线程 void interrupt()：中断线程，别用这个方式 boolean isAlive()：测试线程是否处于活动状态 停止线程 不推荐使用JDK提供的stop()、destroy()方法..
java基础三线程
08-08 232
JAVA 线程初探 java创建线程方式只有new Thread，底层是native方法涉及到C++ 运行方式有三种分别为 1、继承Thread类 2、实现Runnable接口的实现类，重写run方法（无返回值） 3、实现Callable接口的实现类，重写run方法（有返回值）（一般用在线程池中） 由于java是单继承，所以第一种放不建议使用， 下面看下三种方式的代码：...
Java 3 多线程
weixin_43796689的博客
09-21 129
Java3 多线程 资料来源：《Java程序设计基础（第六版）》 Java支持多线程，使各代码段并发执行。 Q：并发和并行的区别 A：并行是指同一时刻有多个代码在处理器上执行，需硬件支持；并发执行是在单处理器上，同一时刻只能执行一个代码，但同一时段内代码段交替执行，实现“微观串行，宏观并行”。 基本概念： 程序（program）：静态的代码 进程（process）：一个运行中的程序。进程是操作系统资源分配和处理器调度的基本单元。 线程（thread）：包含在进程内，同类的多个线程共享内存空间和系统资源 线程
Java多线程（三）
wujingyicode的博客
05-22 125
1、什么是锁 锁我们可以理解为一个通行证，一个线程想要对某个共享资源进行访问，需要先获取该资源的通行证（获取锁），并且通行证只能被一个线程持有。通行证持有线程在结束对这些共享数据的访问后必须让出通行证（释放锁），以便其他线程能获取通行证，对该共享资源进行访问。在线程持有锁到释放锁这段时间所执行的代码被称为临界区。临界区一次只能被一个线程执行。 2、锁的作用 锁可以保证共享资源的原子性，可见性，以及...
java向多线程中传递参数的三种方法详细介绍
09-05
在Java编程中，多线程环境下的数据传递与同步开发模式下的方式有所不同，因为线程的执行顺序和结束时间是不确定的，无法像普通函数那样直接通过参数和返回值进行数据交互。以下将详细介绍三种向Java多线程传递参数的...
qt websocket 客户端 多线程使用
09-16
qt 使用QWebSocket 创建websocket客户端来读取数据，异步链接，并且放入到线程中去执行，线程池的基础，代码使用两个用户，放入到一个线程中执行，同理，可以多个用户放入到多个线程中执行，为线程池执行websocket ...
C++在多线程中使用mciSendString播放音乐demoB
02-06
本示例"C++在多线程中使用mciSendString播放音乐demoB"着重于如何在多线程环境下利用Windows Multimedia Control Interface (MCI) 函数mciSendString来实现音乐播放。下面我们将深入探讨这两个关键概念。 首先，多...
stm32单片机多线程实例
12-03
10. **RTOS应用案例**：可能包含了实际的硬件接口操作，如LED闪烁、串口通信、液晶显示等，通过这些实例来演示多线程在实际项目中的应用。 通过学习这个示例项目，开发者不仅可以掌握STM32单片机的RT-Thread多线程...
C# UDP多线程发送接收
01-23
总结，C# UDP多线程通信是网络编程中的一个重要实践，它结合了UDP的高效传输特性和多线程的并发优势，适用于处理大量并发的网络请求。在实际项目中，开发者需要根据具体需求选择合适的同步机制，保证程序的稳定性和...
JAVA 三种线程实现创建方式
qq_43203949的博客
04-07 126
JAVA 三种线程实现/创建方式 方式一：继承Thread类 通过继承Thread类来创建一个自定义线程类。Thread类本质上就继承了Runable接口，代表一个线程类。启动线程的唯一办法就是通过Thread类的start()实例方法。start()方法是一个 native 方法（本地方法），它将启动一个新线程，并执行 run()方法。 public class MyThread extends Thread { //重写父类的run方法，实现自定义线程操作 public void run()
JAVA多线程——线程状态和线程方法
万里顾一程的博客
09-01 309
JAVA多线程——线程状态和线程方法 线程状态 创建状态：Thread t = new Thread () 就绪状态： 调用start()方法，线程立即进入就绪状态，但不立即调度执行 运行状态：通过CPU进行调度执行，线程才执行线程体的代码块 阻塞状态： 调用sleep，wait或同步锁定时，进入阻塞状态，阻塞状态解除后，线程重新进入就绪状态，等待CPU调度 死亡状态：一旦进入死亡状态，就不能再次启动 package com.peng.demon05; //观察线程状态 pu
java多线程编程基础
wly5503的博客
04-05 282
线程概念 创建新线程 从Thread派生； 实现Runnable接口（不需要返回结果）； 通过 Callable 和 Future 创建线程（需要返回结果）； 必须调用start()方法才能启动新线程 Thread.sleep()可以把当前线程暂停一段时间 线程的状态 一个线程对象只能调用一次start() Java线程对象Thread的状态包括： New / Runnable / Block...
线程的五大状态
z69183787的专栏
03-24 989
线程从创建、运行到结束总是处于下面五个状态之一：新建状态、就绪状态、运行状态、阻塞状态及死亡状态。     1.新建状态(New)：          当用new操作符创建一个线程时， 例如new Thread(r)，线程还没有开始运行，此时线程处在新建状态。 当一个线程处于新生状态时，程序还没有开始运行线程中的代码      2.就绪状态(Runnable)     
java线程详解（史上最全）
05-09 2万+
根据本人多年从业以及学习经验，录制了一套最新的Java精讲视频教程，如果你现在也在学习Java，在入门学习Java的过程当中缺乏系统的学习教程，你可以加QQ群654631948领取下学习资料，面试题，开发工具等，群里有资深java老师做答疑，每天也会有基础部分及架构的直播课，也可以加我的微信renlliang2013做深入沟通，只要是真心想学习Java的人都欢迎。 java基础教程：https:...
java三线程交替打印123……n
孤星可
03-11 2277
使用多线程交替打印1--n，a进程打印1,4,7,……（3n+1）,b进程打印2,7,10,……（3n+2）,c进程打印3,6,9,……（3n） 涉及到多线程的同步，阻塞，wait,notify 代码如下 Num.java public class Num { private int num = 0; public Num(int num) { this.num = nu
【Java】创建线程的三种方式及Thread常用方法——Java多线程（一）
一顿输出
04-22 2588
一、创建线程的方式 方式一：继承Thread类 1）① 新建一个类，这个类继承了Thread，此时这个实现类就是一个线程类了。② 在线程类中重写Thread类的run()方法，重写的run方法中是线程类要执行的代码。③ 当要开启新线程时，调用线程类的start()方法。 2）注意： ① 主线程与子线程：java程序中的main方法称为主线程，在main方法中调用线程类来开启的线程称为子线程。 ② 调用线程类时，使用start()方法，而不能使用run()方法。虽然执行start()方法之后，线程类同样执行的
JAVA多线程实现的三种方式
热门推荐
步春良
07-31 56万+
JAVA多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。 1、继承Thread类实现多线程 继承Thread类的方法尽管被我列为一种多线程实现方式，但Thread本质上也是实现了Runnable接口的一个实例
JAVA多线程执行结果汇总，多线程执行，将结果汇总后返回给主线程
尽量致力于发表微服务、中间件和算法等原创作品。
06-01 9321
/** * 多线程执行结果汇总工具 * * @author 张帅 * @date 2021年05月20日 11时28分02秒 * @version V1.0 * * @param <T> */ @Slf4j public class MultiFutureThread<T> { // 总线程数量 private int threadSize; // 单次执行多少次线程 private int singleSize; ...
java多线程中的datainputstream
最新发布
07-24
在Java多线程中，DataInputStream是一个用于从输入流中读取基本数据类型的类。它是InputStream的子类，可以与多线程一起使用。DataInputStream提供了许多用于读取不同数据类型的方法，例如readInt()、readLong()、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值