四、线程常用方法使用

小涂学编程

已于 2024-03-18 22:03:02 修改

阅读量141

点赞数

分类专栏： # 多线程文章标签： java 数据结构 jvm

于 2022-11-30 23:23:51 首次发布

本文链接：https://blog.csdn.net/qq_45905724/article/details/128120671

版权

多线程专栏收录该内容

17 篇文章 0 订阅

订阅专栏

本文详细介绍了Java线程的常用方法，包括获取当前线程、设置和获取线程名字、线程休眠、中断休眠、停止线程以及线程调度。通过实例展示了如何使用`Thread.sleep()`、`interrupt()`以及`join()`等方法，并讨论了线程优先级和调度策略。此外，还提到了避免使用`stop`方法的原因和合理结束线程执行的方式。

摘要由CSDN通过智能技术生成

七、Java中合理结束一个进程的执行（常用）

关于线程的调度

常见的调度模式

关于线程调度的方法

线程常用方法使用

一、获取当前线程对象

static Thread currentThread() 返回值t就是当前线程

package 多线程;

public class ThreadTest05 {
    public static void main(String[] args) {
        // 创建线程对象，采用匿名内部类方式。
        Thread t1 = new Thread(() -> {
            for(int i = 0; i < 5; i++){
                System.out.println("t1线程---> " + i);
                Thread currentThread = Thread.currentThread();
                System.out.println("当前线程" + currentThread);
            }
        });

        // 启动线程
        t1.start();

        for(int i = 0; i < 5; i++){
            System.out.println("main线程---> " + i);
        }
    }
}

二、获取线程对象名字

String getName() 获取线程对象

package 多线程;

public class ThreadTest05 {
    public static void main(String[] args) {
        // 创建线程对象，采用匿名内部类方式。
        Thread t1 = new Thread(() -> {
            for(int i = 0; i < 5; i++){
                Thread currentThread = Thread.currentThread();
                System.out.println("当前线程对象名称为" + currentThread.getName());
            }
        });

        // 启动线程
        t1.start();

        for(int i = 0; i < 5; i++){
            System.out.println("main线程---> " + i);
        }
    }
}

三、修改线程对象的名字

void setName(String name) 修改线程对象名称

package 多线程;

public class ThreadTest05 {
    public static void main(String[] args) {
        // 创建线程对象，采用匿名内部类方式。
        Thread t1 = new Thread(() -> {
            for(int i = 0; i < 5; i++){
                Thread currentThread = Thread.currentThread();
                currentThread.setName("我的线程");
                System.out.println("当前线程对象名称为" + currentThread.getName());
            }
        });

        // 启动线程
        t1.start();

        for(int i = 0; i < 5; i++){
            System.out.println("main线程---> " + i);
        }
    }
}

四、线程的sleep方法

static void sleep(long millis) 让当前线程休眠millis秒

让当前线程进入休眠状态，进入休眠状态，放弃占有cpu时间片，让给其他线程使用出现在那个线程中，就让那个线程休眠。可以达到这种效果：间隔一定的时间，去执行一段特定的代码。

向我们在日常开发中异步消费处理的时候，之前的分支线程处理还未结束，但是当前的线程需要分支处理结束的结果，所以需要让当前线程睡眠几秒，等待分支线程处理结束即可。

package 多线程;

//线程睡眠
public class ThreadTest06 {
    public static void main(String[] args) {
        //每打印一个数字睡1s
        for(int i = 0; i < 10; i++){
            System.out.println(Thread.currentThread().getName() + "--->" + i);

            // 睡眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

五、线程中断sleep()的方法

void interrupt() 终止线程的睡眠

package 多线程;
public class ThreadTest07 {
    public static void main(String[] args) {


        Thread t = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "--->开始");
            for(int i = 0; i < 100; i++){
                System.out.println("t1线程---> " + i);
                try {
                    // 睡眠1年
                    Thread.sleep(1000 * 60 * 60 * 24 * 365);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //1年之后才会执行这里
                System.out.println(Thread.currentThread().getName() + "---> 结束");
            }
        });
        t.start();
        // 希望5秒之后，t线程醒来（5秒之后主线程手里的活儿干完了。）
        try {
            Thread.sleep(1000 * 5);
    System.out.println(Thread.currentThread());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t.interrupt();
    }
}

这里先让分支线程（t1线程）先睡一年时间，主线程睡5s之后，然后强制中断分支线程的睡眠

六、强行终止一个线程的执行 stop

用法与 interrupt() 一致，但是不建议使用

这种方式存在很大的缺点：容易丢失数据。

因为这种方式是直接将线程杀死了，线程没有保存的数据将会丢失。不建议使用。

七、Java中合理结束一个进程的执行（常用）

package 多线程;public class ThreadTest09 {
    public static void main(String[] args) {
        MyRunable4 r = new MyRunable4();
        Thread t = new Thread(r);
        t.setName("我的线程");
        t.start();

        // 模拟5秒
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 终止线程
        // 你想要什么时候终止t的执行，那么你把标记修改为false，就结束了。(5s后就为false不会执行下面的线程的方法)
        r.run = false;
    }
}

class MyRunable4 implements Runnable {

    // 打一个布尔标记
    boolean run = true;

    @Override
    public void run() {
        for (int i = 0; i < 10; i++){
            if(run){
                System.out.println(Thread.currentThread().getName() + "--->" + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else{
                // return就结束了，你在结束之前还有什么没保存的。
                // 在这里可以保存呀。
                //save....

                //终止当前线程
                return;
            }
        }
    }
}

关于线程的调度

常见的调度模式

抢占式调度模型：那个线程的优先级比较高，抢到的CPU时间片的概率就高一些/多一些。java采用的就是抢占式调度模型。
均分式调度模型：平均分配CPU时间片。每个线程占有的CPU时间片时间长度一样。平均分配，一切平等。有一些编程语言，线程调度模型采用的是这种方式。

关于线程调度的方法

方法名	作用
int getPriority()	获得线程优先级
void setPriority(int newPriority)	设置线程优先级
static void yield()	让位方法，当前线程暂停，回到就绪状态，让给其它线程。
void join()	将一个线程合并到当前线程中，当前线程受阻塞，加入的线程执行直到结束

最低优先级1 static int MIN_PRIORITY
默认优先级是5 static int NORM_PRIORITY
最高优先级10 static int MAX_PRIORITY

注意：

优先级比较高的获取CPU时间片可能会多一些。
yield()方法不是阻塞方法。让当前线程让位，让给其它线程使用。
yield()方法的执行会让当前线程从“运行状态”回到“就绪状态”。在回到就绪之后，有可能还会再次抢到。而阻塞状态时只有阻塞解除的时候才能够去抢夺cpu，阻塞不解除不可能再次抢到cpu。
一个线程.join()，当前线程会进入”阻塞状态“。等待加入线程执行完！

package 多线程;

public class ThreadTest11 {
    public static void main(String[] args) {
        System.out.println("main begin");
        System.out.println("最高优先级：" + Thread.MAX_PRIORITY);//最高优先级：10
        System.out.println("最低优先级:" + Thread.MIN_PRIORITY);//最低优先级:1
        System.out.println("默认优先级:" + Thread.NORM_PRIORITY);//默认优先级:5

        Thread t = new Thread(new MyRunnable7());
        t.setName("t");
        t.start();
        Thread.currentThread().setPriority(10);
        System.out.println("当前线程的优先级" + Thread.currentThread().getPriority());
        //合并线程
        try {
            t.join(); // t合并到当前线程中，当前线程受阻塞，t线程执行直到结束。
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("main over");
    }
}

class MyRunnable7 implements Runnable {

    @Override
    public void run() {
        for(int i = 0; i < 10; i++){
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}

当前线程的优先级设为最高，但是调用join方法，即使main线程优先级最高，但是还是要等待分支线程执行完成，才能执行。