多线程中常用的一些方法介绍

车到山前必有路529

已于 2024-04-10 01:59:29 修改

阅读量775

点赞数 11

文章标签： java 多线程线程常用方法介绍 wait notify notifyAll

于 2024-04-04 19:22:47 首次发布

本文链接：https://blog.csdn.net/qq_65568592/article/details/137380458

版权

1. setName和getName方法

2. 静态方法currentThread

3. 静态方法sleep

4. setPriority和getPriority方法

5. setDaemon方法

6. 静态方法yield

7. join方法

8.wait、notify、notifyAll方法

下面介绍这些方法的使用，以下面的MyThread为例：

public class MyThread extends Thread{

    //由于子类不能继承父类的构造方法，所以需要自己写一个构造方法
    /*无参构造不需要自己写，因为JVM在运行时会检查有无构造方法，如果没有写则会自动添加一个无参构        
      造，实际上也是调用的父类的无参构造*/
    /*但是一旦自己写了有参构造方法，那JVM就不会自动优化了，因为会检查到已经有一个构造方法了，这时 
      无参构造就需要自己写*/
    public MyThread(String name){

        //这里调用父类Thread的有参构造方法
        super(name);
    }

    public MyThread(){

    }

    @Override
    public void run() {
        for(int i=0;i<100;i++)
            System.out.println(Thread.currentThread().getName()+"正在运行...");
    }
}

1. setName和getName方法

setName用来设置线程的名字，也可以使用构造方法进行设置，因为Thread类就有一个有参构造方法是可以命名的；getName用来获取线程名称。

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

        //如果不命名能否获得线程的名称
        Thread t1=new MyThread();
        Thread tt1=new MyThread();
        System.out.println(t1.getName());
        System.out.println(tt1.getName());

        //间接使用父类的构造器给线程命名
        Thread t2=new MyThread("thread2");
        System.out.println(t2.getName());

        //直接使用Thread的有参构造器
        Thread tt2=new Thread("thread22");
        System.out.println(tt2.getName());

        //使用setName给线程命名
        Thread t3=new MyThread();
        t3.setName("thread3");
        System.out.println(t3.getName());

    }
}

补充：对于子类重写的方法，如果父类的方法没有抛异常，那么子类重写的这个方法也不能抛异常，这种情况下只能使用try-catch来捕捉异常；如果父类的方法抛了异常，那么子类重写的这个方法只能抛出父类所抛异常的父类。比如父类使用了throws NullPointerException，那么子类只能使用NullPointerException的父类，比如RuntimeException。

运行结果：

其中Thread-0和Thread-1是运行时系统赋予的名字，所以每个线程即使不命名也都有自己的名字，我们可以查看Thread类的无参构造函数：

从中可以看到Thread的无参构造函数在创建实例时会进行命名，命名格式为Thread-序号，从0开始，再来看一下nextThreadNum函数：

这里面是有一个静态成员变量threadInitNumber，每创建一个线程就进行++操作，就实现了序号的自增。

下面则是Thread的一个可以设置名称的有参构造函数：

相对于无参构造函数，是直接把“Thread-”和自增函数换成了name。

2. 静态方法currentThread

currentThread用来获取当前运行的线程，在上面的MyThread中可以看到通过调用currentThread先获取到当前线程，再调用getName获取到当前线程的名称。

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

       Thread t=new MyThread();
    
       //通过启动线程来调用run方法，这样获取到的线程就是我们创建的线程
       t.start();
    }
}

运行结果：

3. 静态方法sleep

sleep方法用于让执行它的线程进入一定时间的休眠状态，等时间结束后会自动醒来，然后重新竞争CPU，竞争成功后继续运行代码；它的参数是long型的，用来输入要休眠的时间，单位为毫秒，1000毫秒等于1秒。

JVM在启动时会自动启动多条线程，其中一条就是main线程，用于执行main函数中的代码，使用sleep让main线程休眠：

public class Main {
    public static void main(String[] args) throws InterruptedException {

        System.out.println("休眠前");
        
        //让main线程进行休眠
        Thread.sleep(8000);
        
        System.out.println("休眠结束后");
    }
}

运行结果：

一般使用TimeUnit.单位.sleep(值)来让线程休眠而不是调用Thread.sleep，单位和值也就是将时间分为两部分，一部分是值，另一部分是单位。

4. setPriority和getPriority方法

多线程在占用CPU时有两种方式：一种是抢占式调度，多个线程同时竞争CPU，谁能成功抢到CPU完全是随机的，并且每次分配的CPU占用时间也是随机的；另一种是非抢占式调度，CPU轮流分配给这些线程，每次分配的时间都是差不多的。而java采用的是抢占式调度，多个线程需要进行竞争，谁能抢到CPU完全随机，只不过可以通过设置线程的优先级来提高随机到该线程的概率，注意只是提高了概率，并不是谁优先级高就一定先抢到；优先级从1到10，数字越大优先级越高，默认的优先级是5。

public class Main {
    public static void main(String[] args) throws InterruptedException {

        Thread t1=new MyThread("thread1");
        Thread t2=new MyThread("thread2");

        //查看自己创建的线程的默认优先级和main线程的优先级
        System.out.println(t1.getPriority());
        System.out.println(t2.getPriority());
        System.out.println(Thread.currentThread().getPriority());

    }
}

运行结果优先级都是5：

通过查看Thread的源码就可以知道最小优先级是1，最大优先级是10，默认优先级是5：

可以通过给两个线程设置不同的优先级，多运行几次，看看谁先执行完的次数多：

public class Main {
    public static void main(String[] args) throws InterruptedException {

        Thread t1=new MyThread("thread1");
        Thread t2=new MyThread("thread2");

        //分别设置t1和t2的优先级，运行多次查看哪个线程最后执行完的次数多
        t1.setPriority(2);
        t2.setPriority(10);
        t1.start();
        t2.start();
    }
}

实际运行多次后会发现，由于t2线程设置的优先级为10，所以t2先执行完的次数更多，但也有t1先执行完的情况，这就是为什么说优先级只是提高随机到的概率了。

5. setDaemon方法

这个方法的作用就是将当前线程设置为守护线程，通俗一点来讲就是“备胎线程”，当其他线程运行结束时，守护线程如果还没有执行完就会在很短的时间内陆续结束运行。

至于为什么是陆续结束而不是瞬间就结束，是因为当其他线程运行结束后会告诉守护线程自己执行结束了，这个告诉守护线程的过程也需要时间的，守护线程在这段时间内由于还没有收到结束的信息会继续执行，等收到执行结束的消息后就会立刻停止运行。所以陆续停止运行指的就是这段时间内仍在运行，收到消息后立刻停止运行，并且不同线程收到停止运行所需的时间也不同，就表现为了陆续停止。

这里为了减少演示的时间，另写了一个重复执行10次的线程作为普通线程，上面的MyThread作为守护线程：

//另写的一个线程
public class AnotherThread extends Thread{
    public AnotherThread(String name){
        super(name);
    }

    public AnotherThread(){

    }

    @Override
    public void run() {
        for(int i=0;i<10;i++)
            //同时也修改了MyThread的输出为"第"+i+"次运行"，能够明显的看出运行的次数
            System.out.println(Thread.currentThread().getName()+"第"+i+"次运行");
    }
}

然后开始测试：

public class Main {
    public static void main(String[] args) throws InterruptedException {

        Thread t1=new MyThread("thread1");
        Thread t2=new AnotherThread("thread2");

        //设置t1为守护进程
        t1.setDaemon(true);

        //启动两个线程，观察守护线程t1的运行次数
        t1.start();
        t2.start();
    }
}

运行结果：

由运行结果可以看出，守护线程t1还没有运行完100次循环就结束了，但在普通线程结束后又运行了一段时间，这就是守护线程的陆续运行结束。

6. 静态方法yield

yield方法又叫出让线程或礼让线程，在线程执行时使用，用来出让CPU的占用权，可以使得多个线程在执行时占用CPU的次数更均匀。要注意的是，这个方法只能是让多线程运行的结果尽可能均匀，并不是绝对的，虽然出让了CPU的占用权，但出让后这个线程也可以再次竞争CPU的占用权，由于java使用的是抢占式调度，所以出让CPU后谁能抢到还是随机的，还是有可能出现尽管使用了yield方法还是有某个线程长时间连续执行的现象，通俗的讲就是“给你机会你不中用呀”。

演示：

public MyThread(String name){
        super(name);
    }

    public MyThread(){

    }

    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+"第"+i+"次运行");
            
            //执行完一次输出后出让CPU占用权
            Thread.yield();
        }
            
    }
}

//测试
public class Main {
    public static void main(String[] args) throws InterruptedException {

        Thread t1=new MyThread("thread1");
        Thread t2=new MyThread("thread2");

        //启动两个线程，观察两个线程运行结果是否均匀
        t1.start();
        t2.start();
    }
}

运行结果：

还是有这种给t2线程机会不中用的情况：

也有运行结果均匀的情况：

7. join方法

join方法可以让调用它的线程插入到当前正在运行的线程之前先执行，等其执行完毕后原来的当前线程才会执行。

分三种情况演示：

第一种情况

//MyThread类
public class MyThread extends Thread{

    public MyThread(String name){
        super(name);
    }

    public MyThread(){

    }

    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+"第"+i+"次运行");
        }

    }
}

//第一种情况演示
public class Main {
    public static void main(String[] args) throws InterruptedException {

        Thread t1=new MyThread("thread1");
        
        //在main线程中执行10次打印
        for(int i=0;i<10;i++)
            System.out.println(Thread.currentThread().getName()+"第"+i+"次运行");
        
        t1.start();
        
        t1.join();
    }
}

运行结果：

这种情况join似乎并没有起作用，这是因为先执行的for循环，此时t1线程还没有开启。

第二种情况

public class Main {
    public static void main(String[] args) throws InterruptedException {

        Thread t1=new MyThread("thread1");

        t1.start();

        //在main线程中执行10次打印
        for(int i=0;i<10;i++)
            System.out.println(Thread.currentThread().getName()+"第"+i+"次运行");
        
        t1.join();
    }
}

这种情况join似乎也没有起到作用，这是因为main线程执行到for循环时还没有执行到t1.join，此时还是main线程和t1线程共同抢占CPU。

第三种情况

public class Main {
    public static void main(String[] args) throws InterruptedException {

        Thread t1=new MyThread("thread1");

        t1.start();

        t1.join();

        //在main线程中执行10次打印
        for(int i=0;i<10;i++)
            System.out.println(Thread.currentThread().getName()+"第"+i+"次运行");
    }
}

运行结果：

从结果可以看到这种情况下join起到了作用，main线程不会和t1线程抢夺CPU，t1线程先执行完后main线程的循环部分才开始执行，这是因为先执行的join方法，让t1线程先运行，然后main线程等待t1线程结束后才继续执行，这时才执行for循环。

所以要想join方法起到作用，就要让join方法先于main线程中的其他程序被执行。

8.wait、notify、notifyAll方法

wait方法用来让线程进入等待状态，而notify和notifyAll则负责唤醒处于等待状态的线程，它们一般配合使用。在使用这三个方法时一般需要通过锁对象并且是同一个锁对象来调用，因为这三个方法是Object类的方法，所以任何类型的对象都可以调用这三个方法，使得无论锁对象是什么类型的，都可以进行调用。

至于要通过锁对象调用这三个方法是因为要将使用这个锁对象的线程和锁对象进行绑定。在使用锁对象调用wait方法时，会先将当前线程和锁对象绑定，然后进入等待状态；当使用锁对象调用notify或notifyAll时，它们只会唤醒和这个锁对象绑定的线程，从而不会影响到其他无关的线程。

两个唤醒方法notify和notifyAll是有区别的，notify方法是随机唤醒一个线程，如果有多个线程和同一个锁对象绑定了并且都进入了等待状态，它会随机选取一个唤醒；而notifyAll则是会唤醒所有线程。通常使用notifyAll来唤醒线程，因为notify具有随机性，可能需要唤醒多次才能唤醒我们需要唤醒的线程，但notifyAll可以唤醒所有线程，也就保证了我们需要唤醒的线程能够被唤醒。

那么在调用wait、notify以及notifyAll时究竟都做了哪些操作呢？

wait:

获取监视器锁：
- 调用wait方法的线程必须是锁对象的监视器锁的持有者。如果线程尚未持有该锁，它将会被阻塞，直到它获取到锁。
- 当线程执行到wait方法时，它会释放该锁对象上的监视器锁，允许其他线程获取并持有该锁。监视器锁的介绍见另一篇博客多线程学习-Lock锁以及监视器锁详解-CSDN博客。
进入等待队列：
- 释放监视器锁后，线程并不会立即进入休眠状态。相反，它会被加入到锁对象的等待队列中。
- 等待队列是一个由JVM维护的数据结构，用于存储因调用wait方法而等待的线程。
等待条件满足：
- 线程在等待队列中等待，直到其他线程调用同一锁对象的notify或notifyAll方法来唤醒它。
- notify方法会随机唤醒等待队列中的一个线程，而notifyAll方法会唤醒等待队列中的所有线程。
重新获取监视器锁：
- 当线程被唤醒并从等待队列中移除时，它不会立即执行。相反，它会再次尝试获取锁对象的监视器锁。
- 如果锁对象此时没有被其他线程持有，该线程将成功获取锁并继续执行。如果锁仍然被其他线程持有，该线程将再次被阻塞，直到获取到锁。
继续执行：
- 一旦线程成功获取了监视器锁，它会从wait方法返回，并继续执行后续的代码。

notify和notifyAll:

检查当前线程是否持有锁：在调用notify和notifyAll之前，首先必须确保当前线程持有该对象的监视器锁（对于sychronized）或该锁（对于Lock的实现）。如果没有持有锁，调用notify和notifyAll会抛出IllegalMonitorStateException异常。
唤醒等待队列中的随机一个或所有线程：notify和notifyAll方法会唤醒在此对象监视器上等待的一个或所有线程，这些线程之前通过调用wait方法进入了等待状态。至于为什么是随机唤醒是因为具体唤醒哪个等待的线程由线程调度器随机选择，取决于线程调度器的实现和当前等待队列中线程的状态。
将等待队列中的线程转移到同步队列：在唤醒线程后，这些线程并不会立即执行，它们会被移动到同步队列中（即由等待状态变为阻塞状态）等待重新获取锁。
锁竞争：被唤醒的线程将参与锁竞争，它们会尝试获取锁以便能够继续执行；具体哪个线程能够首先获取锁取决于具体的锁策略和线程调度机制。所以notify和notifyAll只是唤醒等待的线程，并不保证这些线程会立即执行，线程的执行取决于操作系统的线程调度策略。此外，由于线程间的竞争，被唤醒的线程可能需要等待一段时间才能获得锁并执行。
执行线程：一旦线程成功获取锁，它将能够继续执行sychronized块或Lock保护的代码区域中的代码。
释放锁：当线程完成其临界区内（也就是被加锁的所有代码）的任务后应当释放锁，以便其他线程可以获取并执行其任务。对于sychronized而言，在退出同步代码块或同步方法时自动解锁；对于Lock而言，则需要使用unlock方法手动释放锁。

使用代码实现等待和唤醒详见另一篇博客多线程学习-等待唤醒机制-CSDN博客。

补充：wait和sleep的区别

所属的类不同：wait是Object类的方法，即所有的对象都可以使用，这也是任意类型的锁都能调用wait的原因了；而sleep则是Thread类的静态方法，通过类调用的方式使用。
锁是否释放：如果之前已经加了锁，那在调用wait之后则会释放，而sleep则不会释放锁，也就是抱着锁睡觉。
使用的范围不同：wait需要在同步代码块或者同步方法中使用，具体原因详见另一篇博客多线程学习-Lock锁以及监视器锁详解-CSDN博客的监视器锁部分；sleep则可以在任何位置调用，也就是可以在任意地方睡觉。
是否单独使用：wait一般需要配合notify使用，用于唤醒等待的线程，而sleep可以单独使用，时间一到就会自己醒来。

车到山前必有路529

关注

11
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
多线程中常用的一些方法介绍

而java采用的是抢占式调度，多个线程需要进行竞争，谁能抢到CPU完全随机，只不过可以通过设置线程的优先级来提高随机到该线程的概率，注意只是提高了概率，并不是谁优先级高就一定先抢到；要注意的是，这个方法只能是让多线程运行的结果尽可能均匀，并不是绝对的，虽然出让了CPU的占用权，但出让后这个线程也可以再次竞争CPU的占用权，由于java使用的是抢占式调度，所以出让CPU后谁能抢到还是随机的，还是有可能出现尽管使用了yield方法还是有某个线程长时间连续执行的现象，通俗的讲就是“给你机会你不中用呀”。
复制链接

扫一扫