多线程复习（四）线程中一些的方法

于 2022-08-15 01:15:26 发布
阅读量63 收藏
点赞数 2
文章标签： java jvm 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51606563/article/details/126338640
版权

1.3.2 setName()/getName()

thread.setName(线程名称)，设置线程名称 thread.getName() 返回线程名称 通过设置线程名称有有助于程序的调试，提高程序的可读性，建议为每个线程都设置一个能够体现线程功能的名称

1.3.3isAlive（）

thread.isAlive判断当前线程是否处于活动状态。 活动状态：线程以启动并且未终止

主线程

public class Test {
    public static void main(String[] args) {
        SubThread subThread = new SubThread();
        //启动相册线程之前false
        System.out.println("begin=="+subThread.isAlive());
        subThread.start();
        //这个的结果不一定如果子线程结束就会返回false，如果结束就会返回true
        System.out.println("end=="+subThread.isAlive());
    }
}

子线程

public class SubThread extends Thread {
    @Override
    public void run() {
        System.out.println("run方法，isAlive"+this.isAlive());
    }
}

运行结果

begin==false
end==true //这个结果不一定
run方法，isAlivetrue

1.3.4 sleep（）

Thread.sleep(millis);让当前线程休眠指定的毫秒数 当前线程是指Thread.currentThread()返回的线程 主线程

public class Test {
    public static void main(String[] args) {
        SubThread subThread = new SubThread();
        System.out.println("main_begin="+System.currentTimeMillis());
        subThread.start();
        System.out.println("main_end="+System.currentTimeMillis());
    }
}

子线程

public class SubThread  extends Thread{
    @Override
    public void run() {
        System.out.println("run threadname="+Thread.currentThread().getName()+"begin="+System.currentTimeMillis());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            //在子线程的run方法中，如果有受检异常（编译时异常）需要处理，只有选则捕获异常，不能抛出处理
            e.printStackTrace();
        }
        System.out.println("run threadname="+Thread.currentThread().getName()+"end="+System.currentTimeMillis());
    }
}

运行结果

main_begin=1660491805852
main_end=1660491805852
run threadname=Thread-0begin=1660491805853
run threadname=Thread-0end=1660491808854

简易的计时器

/*
* 使用线程休眠Thread.sleep完成一个简易的计时器
* */
public class SimpleTimer {
    public static void main(String[] args) {
        int remaining = 60;//从60秒开始计时
        //读取main方法的参数
        if(args.length == 1){
            remaining =Integer.parseInt(args[0]);
        }
        while (true){
            System.out.println("Remaining:"+remaining);
            remaining--;
            if(remaining<0){
                break;
            }
            try {
                Thread.sleep(1000); //线程休眠
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("Done!!!");
    }
}

1.3.5 getId()

thread.getId()可以获得线程的唯一标识

注意： 某个编号的线程运行结束后，该编号可能被后续创建的线程使用。 重启JVM后，同一个线程可能不一样

主线程

public class Test {
    public static void main(String[] args) {

        System.out.println("main name = "+Thread.currentThread().getName());
        System.out.println( "id =="+ Thread.currentThread().getId());

        //子线程的id
        for (int i = 0; i < 3; i++) {
            new SubThread().start();
        }
    }
}

子线程

public class SubThread extends Thread{
    @Override
    public void run() {
        System.out.println("thread name = "+Thread.currentThread().getName());
        System.out.println( "id =="+ this.getId());
    }
}

运行结果

main name = main
id ==1
thread name = Thread-0
id ==12
thread name = Thread-1
id ==13
thread name = Thread-2
id ==14

1.3.6 yield（）

Thread.yield()方法的作用是放弃当前的CPU资源

主线程

public class Test {
    public static void main(String[] args) {
        SubThread subThread = new SubThread();
        subThread.start();
        long begin = System.currentTimeMillis();
        int sum=0;
        for (int i = 0; i < 10000000; i++) {
            sum=+i;
        }
        long end = System.currentTimeMillis();
        System.out.println("main用时"+(end-begin));
    }
}

子线程

public class SubThread extends Thread {
    @Override
    public void run() {
        long begin = System.currentTimeMillis();
         int sum=0;
        for (int i = 0; i < 10000000; i++) {
            sum=+i;
            Thread.yield();//线程让步，放弃CPU执行权
        }
        long end = System.currentTimeMillis();
        System.out.println("用时"+(end-begin));
    }
}

运行结果，如果子线程不让步的话，两个线程用时会差不多

main用时1
用时8505

1.3.7 setPrioriy（）

thread.setPriority(num);设置线程的优先权

java线程的优先权取值范围是1~10如果超出这个范围会抛出异常

在操作系统中，优先级较高的线程获得CPU的资源越多

线程优先级本质上是只是给线程调度器一个提示信息，以便于调度器决定先调度那些线程，

注意不能保证优先级高的线程先运行

Java优先级设置不当或者滥用可能会导致某些线程永远无法得到运行，即产生了线程饥饿。

线程的优先级并不是设置的越高越好，一般情况下使用普通的优先级即可，即在开发时不必设置线程的优先级

线程的优先级具有继承性，如果在A线程中创建了B线程，则B的优先级与A优先级一样

主线程

public class Test {
    public static void main(String[] args) {
        SubThread subThread = new SubThread();
        subThread.setPriority(1);


        SubThreadII subThreadII = new SubThreadII();
        subThreadII.setPriority(10);
         
        subThread.start();
        subThreadII.start();
    }
}

子线程一

public class SubThread extends Thread{
    @Override
    public void run() {
        int sum=0;
        for (int i = 0; i < 1000000000; i++) {
            sum=+i;
        }
        System.out.println("子线程一");
    }
}

子线程二

public class SubThreadII extends Thread {
    @Override
    public void run() {
        int sum=0;
        for (int i = 0; i < 1000000000; i++) {
            sum=+i;
        }
        System.out.println("子线程二");
    }
}

运行结果

子线程二
子线程一

1.3.8 interrupt（）

中断线程

注意：调用interr()方法仅仅是在当前线程打一个停止标志，并不是真正的停止线程

主线程

public class Test {
    public static void main(String[] args) {
        SubThread subThread = new SubThread();
        subThread.start();//开启子线程

        //当前是main线程
        for (int i = 0; i < 10; i++) {
            System.out.println("main==>"+i);
        }

        //中断子线程
        subThread.interrupt();
    }
}

子线程         

public class Test {
    public static void main(String[] args) {
        SubThread subThread = new SubThread();
        subThread.start();//开启子线程

        //当前是main线程
        for (int i = 0; i < 10; i++) {
            System.out.println("main==>"+i);
        }

        //中断子线程
        subThread.interrupt();
    }
}

运行结果

main==>0
sub==>0
sub==>1
sub==>2
sub==>3
sub==>4
main==>1
main==>2
sub==>5
main==>3
main==>4
main==>5
main==>6
main==>7
main==>8
main==>9
sub==>6
sub==>7
sub==>8
sub==>9

由运行结果我们可以看出，虽然在main线程结束以后使用了 subThread.interrupt();但是子线程并没有结束

我们可以结合isInterrupted()方法来手动中断线程

子线程

public class SubThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            //判断线程的中断标志
            if(this.isInterrupted()){
                System.out.println("线程中断");
                break;//中断循环
            }
            System.out.println("sub==>"+i);
        }
    }
}

运行结果

main==>0
main==>1
main==>2
main==>3
main==>4
main==>5
sub==>0
sub==>1
main==>6
main==>7
main==>8
main==>9
sub==>2
线程中断

1.3.9 setDaemon（）

java中的线程分为用户线程和守护线程

守护线程是为其他线程提供服务的线程，如垃圾回收器，就是一个典型的守护线程。

守护线程不能单独运行，当一个JVM只剩下守护线程的时候，守护线程就会自动销毁，JVM会退出

主线程

public class Test {
    public static void main(String[] args) {
        SubDaemonThread subDaemonThread = new SubDaemonThread();
        subDaemonThread.setDaemon(true);//设置守护线程的代码要在启动前
        subDaemonThread.start();

        for (int i = 0; i < 10; i++) {
            System.out.println(i);
        }
    }
}

子线程

public class SubDaemonThread extends Thread {
    @Override
    public void run() {
        while (true){
            System.out.println("守护线程");
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果

0
1
2
3
4
5
6
7
8
9
守护线程
//为什么在主线程结束之后会有守护线程执行？
//因为销毁线程需要时间

洛.rar
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
(一)java多线程之Thread
天之妖星的专栏
10-28 8489
(一)java多线程之Thread本人邮箱: kco1989@qq.com 欢迎转载,转载请注明网址 http://blog.csdn.net/tianshi_kco github: https://github.com/kco1989/kco代码已经全部托管github有需要的同学自行下载一java多线程之Thread 代码已经全部托管github有需要的同学自行下载 Thread类 创建一个
SubThread.java
09-11
SubThread.java
多线程-创建线程的三种方式
neven7的专栏
12-10 707
一.通过继承Thread类实现 1.子类SubThread继承Thread 2.重写run()方法：子线程的执行体 3.创建子类SubThread，并调用start()：启动线程 public class subThread1 extends Thread{ public subThread1(){ System.out.println("构造函数"); } i
创建多线程的三种方式
KyleWong的博客
08-25 179
首先需要理解清楚程序、进程、线程 程序：即静态的代码块； 进程：执行中的进程； 线程：进程的进一部细分，程序的一条执行路径； 第一种 创建一个类继承Thread，并重写run()方法 /第一种方法：创建一个继承Thread的子类 class SubThread extends Thread{ //重写run() public void run(){ /...
【多线程-Suspend()和Resume()方法】
HilaryHe
05-19 8364
Suspend()用于挂起线程，Resume()用于继续执行已经挂起的线程。可以使用这两个方法进行线程的同步，和Start()方法有些类似的是：在调用Suspend方法后不会立即的停止，而是执行到一个安全点后挂起。 class Program { private static Thread subthread ; private static st
E05_多线程复习.pdf
11-02
在计算机科学中，多线程是并发编程的重要概念，它允许多个任务在同一时间执行，提高了系统的效率和响应性。本文将深入探讨多线程的相关知识点。 1. **进程与线程** - **进程**：是操作系统分配资源的基本单位，每...
C#多线程复习题目80道+答案
10-10
此资源有利于初学者巩固C#多线程的基础知识，内有80道练习题及答案。
java多线程应用实现方法
01-01
—————————————————————————————————————————————————- java中的多线程 在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runabl
Java多线程下载的实现方法
09-05
复习多线程的时候，练习了下，顺便记录一下：
Java期末复习||应用程序设计-多线程和泛型
08-02
Java应用程序设计之多线程和泛型 Thread、Runnable、Callable 线程操作：isAlive()、isInterrupted()、join()、sleep()、stop()、interrupted()、setDaemon()、setPriority()、yield() 同步与死锁、Object类对线程的...
进程创建java源代码_java创建线程的两种方式及源码解析
weixin_32493245的博客
02-25 145
创建线程的方式有很多种，下面我们就最基本的两种方式进行说明。主要先介绍使用方式，再从源码角度进行解析。 继承Thread类的方式实现Runnable接口的方式这两种方式是最基本的创建线程的方式，其实核心也就是Thread类，后面分析源码会讲到，下面先介绍使用方式。一：继承Thread类的方式创建线程1，创建线程步骤 创建一个子类继承于Thread类子类重写Thread类的run方法，方法内实现子线...
subthread(handling busy operation) notify mainthread to update UI
Trending Up...
05-24 967
Call PostMessage inside TMyThread.Execute to tell Main Form to update UIunit MyConsts;interfaceuses Messages;const WM_UPDATE_STATUS = WM_USER + 1;implementationend.//////////////////////
java基础线程_Java基础之多线程编程
weixin_36411280的博客
02-16 75
回顾在上一篇 Java基础之线程那些事 我们介绍了关于线程和进程的相关概念，还留下了个题目：即三个窗口同时卖100张票的问题，那么今天就来说说多线程编程的实现。构建多线程主要有继承和实现两种方法多线程创建1.继承Thread类继承的方法即构建一个类继承于Thread类，并实现run方法，具体如下class SubThread extends Thread{@Overridepublic void...
stop subthread example with Event
gate0088的专栏
06-06 394
BackgroundPython threading模块不同于其他语言之处在于它没有提供线程的终止方法，通过Python threading.Thread()启动的线程彼此是独立的，启动了线程B，B是独立运行的线程。若想终止线程的同时强力终止线程B，更为妥当的方式是通过Event机制， 线程中的资源（打开的文件、数据传输等）可正确的释放。 code#-*-coding:utf-8-*- import
【多线程-Join()方法】
HilaryHe
05-12 2778
一. 什么时候使用Join()方法： 当一个线程操作需要等待另一个线程执行完毕之后才能继续进行时，使用Join()方法。 二. 使用： 比如这里我们要在subthread线程执行完毕，然后才能执行主线程：在下面代码中会出现主线程执行完了，subthread线程还在执行，与我们所要求的想反。 class Program { private static T
Java多线程（一）线程的概念
Bright
07-08 219
本文目录： 进程和线程 线程创建方式 线程的状态 中断线程 守护线程 进程和线程 什么是进程和线程？ 在计算机中，一个任务就是一个进程 在进程内部还需要多个子任务，每个子任务被称为线程。 一个进程可以包含一个或多个线程（至少一个）。 进程和线程的关系 一个进程可以包含一个或多个线程（至少一个线程） 线程是操作系统调度的最小任务单位 如何调度线程完全由操作系统决定 实现多任务的方法 多进程模式...
CSDN第一期总结之三：Thread的问题
热门推荐
愚翁专栏
08-24 4万+
C#是一门支持多线程的语言，因此线程的使用也是比较常见的。由于线程的知识在Win32编程的时候已经说得过多，所以在.Net中很少介绍这部分（可能.Net不觉得这部分是它所特有的）。 那么线程相关的问题大致有如下四类（这篇文章只讨论单线程、单线程与UI线程这两方面的问题）。问题一，线程的基本操作，例如：暂停、继续、停止等；问题二，如何向线程传递参数或者从中得到其返回值；问题三，如
BrowserProcessSubThread
飞鸟的专栏
05-26 1947
BrowserProcessSubThreadchromium WinMain中说到，浏览器主进程Browser的工作线程一部分，其类是BrowserProcessSubThread数据结构，那么我们来分析一下这个类。这个类继承自BrowserThreadImpl，而后者继承BrowserThread和base::Thread。base::Thread继承PlatformThread::Delega
JAVA多线程面试题2023
最新发布
07-30
这里整理了一些常见的Java多线程面试题，希望能帮助你在面试前进行复习并找到一个好的工作。[1]以下是一些示例题目： 1. 如何创建一个线程？ 可以通过继承Thread类或实现Runnable接口来创建一个线程。继承Thread类...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值