JavaSE笔记7.9-多线程-Thread类的其他方法

最新推荐文章于 2022-03-04 14:36:49 发布
最新推荐文章于 2022-03-04 14:36:49 发布
阅读量135 收藏
点赞数
分类专栏： JavaSE 文章标签： 多线程 thread java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38503984/article/details/104462379
版权

1. setDaemon()

在这里插入图片描述

（1）守护线程特点

线程分为两种：用户线程（User Thread）和守护线程（Daemon Thread）。
守护线程特点：开启后，和用户线程共同抢夺CPU的执行权运行（开启和运行都和用户线程无区别）；当所有的用户线程都结束后，守护线程会自动结束。

（2）未使用setDaemon( )
class StopThread implements Runnable{
    private boolean flag=true;
    public synchronized void run(){
        while (flag){
            try{
                wait();
            }
            catch (InterruptedException e){
                System.out.println(Thread.currentThread().getName()+"...Exception");
            }
            System.out.println(Thread.currentThread().getName()+"...run");
        }
    }
}
class StopThreadDemo{
    public static void main(String[] args){
        StopThread st=new StopThread();
        Thread t1=new Thread(st);
        Thread t2=new Thread(st);
        t1.start();
        t2.start();
        int num=0;
        while (true){
            if(num++==60){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"...run"+num);
        }
        System.out.println("over");
    }
}

运行结果是：
线程t1和t2被冻结，不能终止，运行未结束。
在这里插入图片描述

（3）使用setDaemon( )
class StopThread implements Runnable{
    private boolean flag=true;
    public synchronized void run(){
        while (flag){
            try{
                wait();
            }
            catch (InterruptedException e){
                System.out.println(Thread.currentThread().getName()+"...Exception");
            }
            System.out.println(Thread.currentThread().getName()+"...run");
        }
    }
}
class StopThreadDemo{
    public static void main(String[] args){
        StopThread st=new StopThread();
        Thread t1=new Thread(st);
        Thread t2=new Thread(st);
        //将线程t1和t2标记为守护线程
        t1.setDaemon(true);
        t2.setDaemon(true);

        //将线程设置为守护线程后才启动
        t1.start();
        t2.start();
        int num=0;
        while (true){
            if(num++==60){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"...run"+num);
        }
        System.out.println("over");
    }
}

运行结果是：
线程t1和t2被冻结，但主线程结束后，守护线程t1和t2自动结束，运行结束。
在这里插入图片描述

2. join( )

在这里插入图片描述

（1）join( )定义
t.join();//等待线程t执行完毕
t.join(1000);//等待线程t执行，等待时间是1000ms

t调用join方法，即抢夺CPU的执行权，主线程将CPU的执行权给t，主线程变为冻结状态；
t线程运行至结束，主线程才恢复到运行状态；

（2）未使用join( )
class Demo implements Runnable{
    public void run(){
        for(int i=0;i<70;i++){
            System.out.println(Thread.currentThread().getName()+"....."+i);
        }
    }
}
class JoinDemo{
    public static void  main(String[] args){
        Demo d=new Demo();
        Thread t1=new Thread(d);
        Thread t2=new Thread(d);
        t1.start();
        t2.start();
        //主线程
        for(int i=0;i<80;i++){
            System.out.println("main....."+i);
        }
        System.out.println("over");
    }
}

运行结果是：
Thread0、Thread1、main三者交替运行
在这里插入图片描述

（3）使用join( )
class Demo implements Runnable{
    public void run(){
        for(int i=0;i<70;i++){
            System.out.println(Thread.currentThread().getName()+"....."+i);
        }
    }
}
class JoinDemo{
    public static void  main(String[] args) throws InterruptedException {
        Demo d=new Demo();
        Thread t1=new Thread(d);
        Thread t2=new Thread(d);
        t1.start();
        
        //在t2启动之前，t1调用join()
        t1.join();
        
        t2.start();
        //主线程
        for(int i=0;i<80;i++){
            System.out.println("main....."+i);
        }
        System.out.println("over");
    }
}

运行结果是：
Thread0先运行至结束，Thread1和main才交替运行

（4）在主线程中写join( )，抢夺的是主线程的执行权
class Demo implements Runnable{
    public void run(){
        for(int i=0;i<70;i++){
            System.out.println(Thread.currentThread().getName()+"....."+i);
        }
    }
}
class JoinDemo{
    public static void  main(String[] args) throws InterruptedException {
        Demo d=new Demo();
        Thread t1=new Thread(d);
        Thread t2=new Thread(d);
        t1.start();
        t2.start();
        
        //在t2启动之后，t1调用join()
        t1.join();
        
        //主线程
        for(int i=0;i<80;i++){
            System.out.println("main....."+i);
        }
        System.out.println("over");
    }
}

运行结果是：
Thread0和Thread1交替运行；但主线程需要等到Thread0结束后才能恢复运行状态

（5）特点

当A线程执行到了B线程的join()时，A线程就会等待，等B线程都执行完，A才会执行。
join()可以用来临时加入线程执行。

当B线程挂着了，A线程也挂着了，可以用interrupt来强制唤醒A线程

3. toString( )

在这里插入图片描述

使用toString( )
class Demo implements Runnable{
    public void run(){
        for(int x=0;x<70;x++){
            System.out.println(Thread.currentThread().toString()+"....."+x);
        }
    }
}
class ToStringDemo{
    public static void main(String[] args){
        Demo d=new Demo();
        Thread t1=new Thread(d);
        Thread t2=new Thread(d);
        t1.start();
        t2.start();
    }
}

运行结果是：
Thread0和Thread1的线程优先级为5，属于线程组main
在这里插入图片描述

4. setPriority( )

（1）优先级
  • 优先级代表着抢夺资源的频率
  • 所有线程包括主线程的默认优先级为5
  • 优先级的区间为1~10
  • 优先级只有1、5、10最明显，有专属的字段名称，定义为静态常量值，增强阅读性
    在这里插入图片描述
（2）使用setPriority( )修改优先级

在这里插入图片描述

class Demo implements Runnable{
    public void run(){
        for(int x=0;x<70;x++){
            System.out.println(Thread.currentThread().toString()+"....."+x);
        }
    }
}
class SetPriorityDemo{
    public static void  main(String[] args){
        Demo d=new Demo();
        Thread t1=new Thread(d);
        Thread t2=new Thread(d);
        t1.start();
        //给线程t1设置最高优先级10
        t1.setPriority(Thread.MAX_PRIORITY);
        t2.start();
    }
}

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

5. yeild( )

（1）作用
  • 放弃当前线程获取CPU的执行权，将让其它的线程去获取（但这个是不固定的）
  • 可以稍微减缓线程执行的频率，减少同一个线程连续多次执行的现象，使得线程有平均运行的机会
（2）不使用yield( )
class Demo implements Runnable{
    public void run(){
        long time=System.currentTimeMillis();
        for(int x=0;x<70;x++){
         System.out.println(Thread.currentThread().toString()+"....."+x);
        }
   }
}
class YieldDemo{
    public static void  main(String[] args){
        Demo d=new Demo();
        Thread t1=new Thread(d);
        Thread t2=new Thread(d);
        t1.start();
        t2.start();
    }
}

运行结果是：
Thread0和Thread1没有交替执行，1个线程连续多次执行

（2）使用yield( )
class Demo implements Runnable{
    public void run(){
        long time=System.currentTimeMillis();
        for(int x=0;x<70;x++){
            System.out.println(Thread.currentThread().toString()+"....."+x);
            //调用yield()
            Thread.yield();
        }
    }
}
class YieldDemo{
    public static void  main(String[] args){
        Demo d=new Demo();
        Thread t1=new Thread(d);
        Thread t2=new Thread(d);
        t1.start();
        t2.start();
    }
}

运行结果是：
Thread0和Thread1开始交替（但这个是不固定的）

又困了天哪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaSe笔记2021-8-2
08-02
同时，笔记可能涉及了多线程，Java提供了Thread类和Runnable接口来创建和管理并发执行的任务，理解线程同步机制（如synchronized关键字、wait()、notify()方法）对于编写多线程程序至关重要。 此外，IO流（Input/...
javase-学习笔记.pdf
最新发布
11-28
javase-学习笔记.pdf
字符串tostring_Java线程类字符串toString（）方法（带示例）
07-02 266
字符串tostring 线程类字符串toString() (Thread Class String toString()) This method is available in java.lang.Thread.toString(). 此方法在java.lang.Thread.toString()中可用。 This method is used to return the string repr...
java中的thread_java中的Thread.currentThread()有什么作用
weixin_35615475的博客
02-12 396
Runnablesonrs=newRunnableson(17);Threadtd=newThread(rs);Threadtd1=newThread(rs);Stringstr=td.currentThread().toString();System.out.println(str);//得出Thread[main,5,main]S...Runnableson rs=new Runnableso...
关于Thread中的toString的问题
zjyzz13的博客
12-02 675
API中的Thread类中有一个toString方法，应该是可以改写输出的内容的，尝试了几遍发现自己不懂实现 尝试代码： package study; public class Example01 { public static void main(String[] args) { Thread t=new toStringThread(); t.toString(); }
java学习(十二)—并发编程(一)
berylpy的博客
11-05 241
一、并发概念 1、并行和并发的区别 并行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔发生。 并发一般解决两种问题，“速度”和“设计可管理性”。这部分事件要么看起来在并发的执行，要么在多处理环境下可以同时执行。 二、基本的线程机制 2.1 定义任务 1、实现接口Runnable接口并编写run()方法，使用方法比较简单。该任务五返回值。 public
java 多线程详解
xiaoqiaoliushui521的博客
11-03 81
1、什么是线程 线程:程序执行流的最小单元【可以理解为：进程中独立运行的子任务】。 2、线程状态 (1).新建(NEW)：新创建了一个线程对象。 (2).可运行(RUNNABLE)：线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu 的使用权 。 (3).运行(RUNNING)：可运行状态(r...
JavaSE专题-多线程总结.doc
06-03
JavaSE专题的多线程是Java编程中至关重要的一部分，它涉及到如何在单个程序中同时执行多个任务。以下是对多线程技术的详细说明： 1. **多线程技术介绍** - **进程**：一个进程是操作系统分配给应用程序的内存空间...
javase-2.2-API文档-中文版.zip
07-13
赠送jar包：javase-2.2.jar； 赠送原API文档：javase-2.2-javadoc.jar； 赠送源代码：javase-2.2-sources.jar； 赠送Maven依赖信息文件：javase-2.2.pom； 包含翻译后的API文档：javase-2.2-javadoc-API文档-中文...
JavaSE原理-日期类API导学.md
02-19
JavaSE原理-日期类API导学.md
Thread.currentThread（）方法、进程、线程、多线程相关总结（二）
he_zhen_的博客
02-16 1万+
Thread.currentThread方法 Thread的静态方法currentThread方法可以用于获取运行当前代码片段的线程
Thread.currentThread()与this的区别
热门推荐
夜子的专栏
03-02 3万+
Thread.currentThread()与this的区别
Thread.currentThread(); 运行到此处时，返回正在运行的线程的引用
qq_39632912的博客
01-17 1759
Thread.currentThread(); 运行到此处时，返回运行到这条语句的线程的引用。。。。。。。。。
多线程同步（安全机制）——Java多线程（2）
小高同学
05-30 1220
线程安全： 如果有多个线程同时运行一段代码，并且运行结果与单线程运行结果是一样的，那么就说是线程安全的。 1.1 线程不安全案例 通过下面这个买票的案例我们会发现会出现两种情况 一张票卖了多次的情况 出现负票的情况 public class Client3 { public static void main(String[] args) { Ticket t = new Ticket(); //同时开启三个售票窗口 Thread thread =
线程篇 --- Thread.currentThread(一)
qq_27721753的博客
09-21 1245
老套路，先说作用，上源码 一、作用 Thread.currentThread是Thread的一个静态本地方法，本地方法就是可以调用其他语言，比如你可以调用你c++，c++再去调用你的Windows的执行程序等等。 先不用去纠结这个native本地方法是啥，不知道无所谓，不影响操作，先操作一通再说 这个方法，他返回一个当前正在运行的线程的实例对象，说白了，就是你当前正在运行的线程，你通过这个方法，...
Thread.currentThread()
qq_44018692的博客
03-04 529
Thread.currentThread()方法并不会创建线程，它只会返回当前正在执行的的线程对象
Thread : currentThread().getName()和getName()的区别
加菲学Java
04-11 506
如下的code: public class Thread_getName2 extends Thread { public void run() { //System.out.println(getName()); System.out.println(currentThread().getName()); } public static void main(S...
python多线程学习总结(一) 参数setDaemon
qq_42470170的博客
07-01 1043
场景: 项目代码中，多线程并不像自己预期的跑下去。所以简化代码，研究下多线程的参数和运行流程 代码: import threading start_time = time.time() def push(num): print('thread_num: {}, start'.format(num)) time.sleep(1) print('thread_num: {}, end'.format(num)) threads = [] t1 = threading.Thread(
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值