Java四个线程常用函数超全使用详解

2024-04-02 19:04:59 476人浏览独家记忆

Python 官方文档：入门教程 => 点击学习

摘要

目录前言1. wait()2. join()3. sleep()4. yield()5. 总结5.1 wait和join的区别5.2 wait和sleep的区别前言之前没怎么关注到

前言

之前没怎么关注到这两个的区别以及源码探讨

后面被某个公司面试问到了，开始查漏补缺

1. wait()

使当前线程等待，直到它被唤醒，通常是通过被通知或被中断，或者直到经过一定的实时时间。

本身属于一个Object 类，查看源代码也可知：public class Object {

查看其源码可知，一共有三个重载的方法，详情源代码如下：

//第一个重载函数
public final void wait() throws InterruptedException {
        wait(0L);
    }
    
//第二个重载函数
public final native void wait(long timeoutMillis) throws InterruptedException;


//第三个重载函数
public final void wait(long timeoutMillis, int nanos) throws InterruptedException {
        if (timeoutMillis < 0) {
            throw new IllegalArgumentException("timeoutMillis value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }

        if (nanos > 0 && timeoutMillis < Long.MAX_VALUE) {
            timeoutMillis++;
        }

        wait(timeoutMillis);
    }

具体实战调用代码如下：

如果执行到了wait函数，在这4秒内，会释放锁，并且暂停线程。如果这四秒内配合notify()可以唤醒并且得到锁，如果没有唤醒，等待其他来竞争。4秒结束后，会默认自动释放锁

当前线程在 Thread.wait()等待过程中，如果Thread结束了，是可以自动唤醒的而且自动释放锁

@Override
public void run() {
       synchronized (a) {
           a.wait(4000);      
       }
}

2. join()

join是Thread类的方法

查看其源码，具体源码如下，三个重载的方法

//第一个重载函数
public final synchronized void join(final long millis)
    throws InterruptedException {
        if (millis > 0) {
            if (isAlive()) {
                final long startTime = System.nanoTime();
                long delay = millis;
                do {
                    wait(delay);
                } while (isAlive() && (delay = millis -
                        TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime)) > 0);
            }
        } else if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            throw new IllegalArgumentException("timeout value is negative");
        }
    }


//第二个重载函数

public final synchronized void join(long millis, int nanos)
throws InterruptedException {

    if (millis < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }

    if (nanos < 0 || nanos > 999999) {
        throw new IllegalArgumentException(
                            "nanosecond timeout value out of range");
    }

    if (nanos > 0 && millis < Long.MAX_VALUE) {
        millis++;
    }

    join(millis);
}


//第三个重载函数

public final void join() throws InterruptedException {
     join(0);
 }

主要的时间参数逻辑如下：

小于0，抛出异常
等于0，join（A），判断A是否存在，存在才执行操作。该线程执行wait（0）等待，等待A线程执行完后才可结束
大于0，同上，只不过执行的是wait（long millis），等待时间结束后才可继续执行操作

3. sleep()

对比上一个wait函数

sleep(long mills)：让出CPU资源，但是不会释放锁资源。
wait()：让出CPU资源和锁资源。

查看sleep函数的源码，一共有两个重载函数

都是Thread类的函数


public static native void sleep(long millis) throws InterruptedException;




public static void sleep(long millis, int nanos)
    throws InterruptedException {
        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }

        if (nanos > 0 && millis < Long.MAX_VALUE) {
            millis++;
        }

        sleep(millis);
    }