Java多线程-02 （线程的常用方法）

最新推荐文章于 2023-10-31 17:49:35 发布

小北呱

最新推荐文章于 2023-10-31 17:49:35 发布

阅读量188

点赞数 1

分类专栏：多线程文章标签：多线程 java getId

本文链接：https://blog.csdn.net/weixin_43260996/article/details/119379556

版权

多线程专栏收录该内容

14 篇文章 2 订阅

订阅专栏

线程的常用方法

个人博客：www.xiaobeigua.icu

1.1 currentThread()方法（类方法）

Thread.currentThread()方法可以获得当前线程

Java 中的任何一段代码都是执行在某个线程当中的.。执行当前代码的线程就是当前线程。

同一段代码可能被不同的线程执行, 因此当前线程是相对的,Thread.currentThread()方法的返回值是在代码实际运行时候的线程对象。

代码：

public class MyThread extends Thread {
    public MyThread() {
        System.out.println(" 构 造 方 法 打 印 当 前 线 程 的 名 称 : " +
                Thread.currentThread().getName());
    }

    @Override
    public void run() {
        System.out.println("run 方 法 打 印 当 前 线 程 名 称 :" +
                Thread.currentThread().getName());
    }
}

测试代码：


public class Test {

    public static void main(String[] args) {

        System.out.println("main 方 法 中 打 印 当 前 线 程 :"         
       +Thread.currentThread().getName());

        //创建子线程, 调用 MyThead()构造方法, 在 main 线程中调用构造方法,所以构造
        //方法中 的当前线程就是 main 线程
        MyThread t1 = new MyThread();

         t1.start(); //启动子线程,子线程会调用 run()方法,所以 run()方法中 的当
        //前线程就是 Thread-0 子线程
       
    }
}

结果：

结论:

创建子线程, 调用 MyThead()构造方法, 在 main 线程中调用构造方法,所以构造方法中的当前线程就是 main 线程

启动子线程,子线程会调用 run()方法,所以 run()方法中的当前线程就是 Thread-0 子线程

1.2 setName()/getName()（实例方法）

thread.setName(线程名称), 设置线程名称。

thread.getName()返回线程名称。

通过设置线程名称,有助于程序调试,提高程序的可读性, 建议为每个线程都设置一个能够体现线程功能的名称

代码：

public class MyThread extends Thread {

    @Override
    public void run() {
        System.out.println("run 方 法 打 印 当 前 线 程 名 称 :" +
                Thread.currentThread().getName());
    }
}

测试代码：

public class Test {

    public static void main(String[] args) {

     MyThread  thread=new MyThread();
     thread.setName("帅气的线程");//设置线程名称，记得一定要在线程启动时设置
     thread.start();

    }
}

结果：

1.3 isAlive() (实例方法)

thread.isAlive()判断当前线程是否处于活动状态。

活动状态就是线程已启动并且尚未终止。

代码：

public class MyThread extends Thread {

        @Override
        public void run() {
            
            //运行状态,true
            System.out.println("run 方法, isalive = " + this.isAlive()); 

}

测试代码：

public class Test {

    public static void main(String[] args) {

        MyThread t3 = new MyThread();

        System.out.println("begin==" + t3.isAlive()); //false,在启动线程之前
        t3.start();
        System.out.println("end==" + t3.isAlive());
        //结果不一定,打印这一行时,如果 t3线程还没结束就返回 true, 如果 t3 线程已结束,返回 false
    }
}

结果：

1.4 sleep() （类方法）

Thread.sleep(millis)：让当前线程休眠指定的毫秒数

当前线程是指 Thread.currentThread()返回的线程

代码：

public class Mythread2 extends Thread {
    @Override
    public void run() {

        //给定60s时间
        int m=60;

        while(true){

            System.out.println(m);
            //相当于时间-1;
            m--;
            if (m<0){
                break;
            }

            //让线程没执行一次循环就休眠一秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

测试代码：

public class Test2 {
    public static void main(String[] args) {
        //创建线程
      Mythread2 mythread2=new Mythread2();
      mythread2.start();//启动线程
    }
}

结果：每秒减1

1.5 getId() （实例方法）

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

注意:

某个编号的线程运行结束后,该编号可能被后续创建的线程使用

重启的 JVM 后,同一个线程的编号可能不一样

代码：

public class MyThread extends Thread {

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

}

测试代码：

public class Test2 {
    public static void main(String[] args) {
        //查看主线程id
        System.out.println( Thread.currentThread().getName() + " , id = "         
                            +Thread.currentThread().getId());

        //循环5次，创建5个子线程， 查看不同子线程的 id
        for(int i = 1; i <= 5; i++){
            new MyThread().start();
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

结果：

1.6 yield() （类方法）

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

代码：

public class MyThread extends Thread {

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

}

测试代码：

public class Test {

    public static void main(String[] args) {

        //创建子线程并启动，开始计算累加
        MyThread myThread=new MyThread();
        myThread.start();

        //在 main 线程中计算累加和
        long begin = System.currentTimeMillis();
        long sum = 0;
        for(int i = 1; i <= 1000000; i++){
            sum += i;
        }
        long end = System.currentTimeMillis();
        System.out.println("main 方法 , 用时: "+(end-begin));
    }

结果：

结论：

在代码中，main方法线程和子线程都进行了累加计算，但是，由于子线程的run()中使用了 Thread.yield()方法，导致子线程每执行一次累加，就要放弃其拥有的cpu资源，然后再进行排队，等待cpu分配资源，所以导致计算完累加耗时比较大。

1.7 setPriority(）（实例方法）

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

java 线程的优先级取值范围是 1 ~ 10 , 默认的优先级是5，如果超出这个范围会抛出异常 IllegalArgumentException。

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

线程优先级本质上是只是给线程调度器一个提示信息,以便于调度器决定先调度哪些线程. 注意不能保证优先级高的线程先运行。

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

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

线程的优先级具有继承性, 在 A 线程中创建了 B 线程,则 B 线程的优先级与 A 线程是一样的。

由于创建线程比较少，设置了看不出区别，所以这里不用代码演示了。

1.8 interrupt（）（实例方法）

中断线程.。

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

代码：

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i=0;i<10000;i++){
            if (this.isInterrupted()){
                System.out.println("当前线程的中断标志为 true, 我要退出了");
                break; //中断循环, run()方法体执行完毕,
            }
            System.out.println("子线程——》"+i);
        }
    }
}

测试代码：


public class Test {

    public static void main(String[] args) {

        MyThread t1 = new MyThread();
        t1.start(); //开启子线程

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

        //中断子线程
        t1.interrupt(); //仅仅是给子线程标记中断,让子线程里面的isInterrupted()去识别


    }
}

结果：

结论：

interrupt()方法仅仅是在当前线程打一个停止标志,并不是真正的停止线程，要想让线程真正的停止，必须要搭配线程的另一个捕获方法isInterrupted()，它用来判断当前线程是否被打了中断停止标志，有就放回布尔值true 没有就是false。

1.9 setDaemon(）（实例方法）

Java 中的线程分为用户线程与守护线程

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

守护线程不能单独运行, 当 JVM 中没有其他用户线程,只有守护线程时,守护线程会自动销毁, JVM 会退出。

代码：

public class MyThread extends Thread {
    @Override
    public void run() {
       //使用死循环，只有线程销毁时才会停止
        while(true){
            System.out.println("sub thread.....");
        }
    }
}

测试代码：

public class Test {

    public static void main(String[] args) {

        MyThread t1 = new MyThread();
        //将当前线程设置为守护线程
        t1.setDaemon(true);
        t1.start(); //开启子线程

        //当前线程为 main 线程
        for(int i = 1; i <= 10000 ; i++){
            System.out.println("main== " + i);
        }

    //当 main 线程结束, 守护线程 thread 也销毁了

    }
}

结果：

结论：

守护线程是可以人为设置的，而且它不能单独运行，当其他用户线程结束时，守护线程也会被销毁

小北呱

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Java多线程-02 （线程的常用方法）

线程的常用方法个人博客：www.xiaobeigua.icu1.1 currentThread()方法（类方法） Thread.currentThread()方法可以获得当前线程...
复制链接

扫一扫