引言
在JDK17（或以上版本）中，Thread类提供了一组常用的API，用于管理线程的创建、启动、暂停、恢复和销毁等操作。本文从api、源码、编程示例等方面详细说明Thread常用函数的使用和注意事项。
线程 sleep
- 使当前正在执行的线程暂停（挂起）指定的毫秒数。但受系统计时器和调度程序的精度和准确性限制。
- 线程不会失去任何monitor（监视器）的所有权。
- 每个线程的休眠互不影响，
Thread.sleep只会导致当前线程进入指定时间的休眠。
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);
}
通过测试发现 Thread.sleep 之间互不影响。代码如下：
/**
* 每个线程的休眠互不影响，`Thread.sleep` 只会导致当前线程进入指定时间的休眠。
*/
public class ThreadSleepTest {
public static void main(String[] args) throws Exception{
Thread thread1 = new Thread(()->{
int i = 0;
while(i<10){
System.out.println("thread demo start "+i);
i++;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
thread1.start();
System.out.println("thread main start ");
Thread.sleep(2000);
System.out.println("thread main end ");
}
}
输出结果如下：
thread main start
thread demo start 0
thread demo start 1
thread main end
thread demo start 2
thread demo start 3
除此之外可以使用 java.util.concurrent.TimeUnit 类来更简单的实现指定时间的休眠，后续源码使用该类来进行休眠线程。例子代码如下：
package engineer.concurrent.battle.abasic;
import java.util.concurrent.TimeUnit;
/**
* TimeUnit工具类替代Thread.sleep方法。
* @author r0ad
* @since 1.0
*/
public class ThreadSleepTimeUnitTest {
public static void main(String[] args) throws Exception{
System.out.println("thread main start ");
TimeUnit.SECONDS.sleep(1);
TimeUnit.MILLISECONDS.sleep(500);
TimeUnit.MINUTES.sleep(1);
System.out.println("thread main end ");
}
}
/**
* java.util.concurrent.TimeUnit#sleep 源码，底层实现也是Thread.sleep。
* Performs a {@link Thread#sleep(long, int) Thread.sleep} using
* this time unit.
* This is a convenience method that converts time arguments into the
* form required by the {@code Thread.sleep} method.
*
* @param timeout the minimum time to sleep. If less than
* or equal to zero, do not sleep at all.
* @throws InterruptedException if interrupted while sleeping
*/
public void sleep(long timeout) throws InterruptedException {
if (timeout > 0) {
long ms = toMillis(timeout);
int ns = excessNanos(timeout, ms);
Thread.sleep(ms, ns);
}
}
线程 yield
Thread.yield()是一个提示，用于告诉调度程序当前线程愿意放弃使用处理器。调度程序可以选择忽略这个提示。Yield是一种试图改善线程之间相对进程的启发式方法，否则它们会过度利用CPU。它的使用应该与详细的分析和基准测试结合起来，以确保它确实产生了预期的效果。
这种方法适用场景很少。它有助于调试或测试，以帮助重现由于竞态条件而引起的错误。在设计并发控制结构时，例如java.util.concurrent.locks包中的结构，它也可能有用。
调用Thread.yield()函数会将当前线程从RUNNING状态切换到RUNNABLE状态。
public static native void yield();
测试代码如下，在cpu资源不紧张的情况下输出仍然是乱序的。
package engineer.concurrent.battle.abasic;
import java.util.stream.IntStream;
/**
* ThreadYield测试
* @author r0ad
* @since 1.0
*/
public class ThreadYieldTest {
public static void main(String[] args) throws Exception{
System.out.println("thread main start ");
IntStream.range(0, 2).mapToObj(ThreadYieldTest::create).forEach(Thread::start);
System.out.println("thread main end ");
}
private static Thread create(int i) {
return new Thread(() -> {
if(i == 0 ){
Thread.yield();
}
System.out.println("thread " + i + " start ");
});
}
}
输出结果：
thread main start
thread main end
thread 0 start
thread 1 start
Thread.yield() 和 Thread.sleep() 方法之间的联系和差异如下：
联系：
- Thread.yield() 和 Thread.sleep() 都会使当前线程暂停执行，让出CPU资源给其他线程。
- Thread.yield() 和 Thread.sleep() 都不会释放当前线程所占用的锁。
差异：
- Thread.yield() 方法只是暂停当前线程的执行，让出CPU资源给其他线程，但不会进入阻塞状态。可能导致CPU进行上下文切换。
- Thread.sleep() 方法会使当前线程暂停指定的时间，并进入阻塞状态，直到休眠时间结束或者被其他线程打断。
- Thread.sleep()具有较高的可靠性，可以确保至少暂停指定的时间。Thread.yield()则不能保证暂停。
设置线程的优先级
java.lang.Thread#setPriority修改线程的优先级java.lang.Thread#getPriority获取线程的优先级
java.lang.Thread#setPriority 修改线程的优先级实现过程如下：
- 调用此线程的
checkAccess方法，不带任何参数。这可能会导致抛出一个SecurityException异常。 - 线程的优先级被设置为指定的
newPriority和线程所属线程组允许的最大优先级中较小的值。
/**
* `java.lang.Thread#setPriority` 修改线程的优先级源码
*/
public final void setPriority(int newPriority) {
ThreadGroup g;
// 调用此线程的`checkAccess`方法，不带任何参数。这可能会导致抛出一个`SecurityException`异常。
checkAccess();
if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
throw new IllegalArgumentException();
}
if((g = getThreadGroup()) != null) {
// 线程的优先级被设置为指定的`newPriority`和线程所属线程组允许的最大优先级中较小的值。
if (newPriority > g.getMaxPriority()) {
newPriority = g.getMaxPriority();
}
setPriority0(priority = newPriority);
}
}
/**
* `java.lang.Thread#getPriority` 获取线程的优先级
*/
public final int getPriority() {
// 返回Thread的priority属性
return priority;
}
/* 原生优先级设置方法 */
private native void setPriority0(int newPriority);
进程有进程的优先级，线程同样也有优先级，理论上是优先级比较高的线程会获取优先被 CPU 调度的机会，但是事实上设置线程的优先级同样也是一个 hint 操作，具体如下。
- 对于 root 用户，它会 hint 操作系统你想要设置的优先级别，否则它会被忽略。
- 如果 CPU 比较忙，设置优先级可能会获得更多的 CPU 时间片，但是闲时优先级的高低几乎不会有任何作用。
所以不要使用线程的优先级进行某些特定业务的绑定，业务执行的顺序应该还是要使用同步执行方法来保证。
测试例子如下，线程之间会交替输出：
package engineer.concurrent.battle.abasic;
/**
* ThreadPriorityTest测试
* @author r0ad
* @since 1.0
*/
public class ThreadPriorityTest {
public static void main(String[] args) throws Exception{
Thread t1 = ThreadPriorityTest.create("t1");
t1.setPriority(1);
Thread t2 = ThreadPriorityTest.create("t2");
t2.setPriority(10);
t1.start();
t2.start();
}
private static Thread create(String name) {
return new Thread(() -> {
while (true) {
System.out.println("thread " + name );
}
});
}
}
获取线程ID
返回此线程的标识符。线程ID是一个正的long数字，在创建此线程时生成。线程ID是唯一的，并在其生命周期内保持不变。当一个线程终止时，该线程ID可能会被重新使用。
public long getId() {
return tid;
}
获取当前线程
java.lang.Thread#currentThread 方法被大多数框架使用，像是SpringMVC、MyBatis这些。调用该函数会返回当前正在执行的线程对象。
@IntrinsicCandidate
public static native Thread currentThread();
测试代码如下：
package engineer.concurrent.battle.abasic;
/**
* ThreadCurrentTest测试
* @author r0ad
* @since 1.0
*/
public class ThreadCurrentTest {
public static void main(String[] args) throws Exception{
Thread t1 = new Thread() {
@Override
public void run() {
System.out.println(this == Thread.currentThread());
}
};
t1.start();
System.out.println(Thread.currentThread().getName());
}
}
设置线程上下文类加载器
java.lang.Thread#getContextClassLoader返回该线程的上下文ClassLoader。上下文ClassLoader由创建线程的对象提供，用于在此线程中运行的代码在加载类和资源时使用。如果未设置（通过setContextClassLoader()方法），则默认为父线程的ClassLoader上下文。原始线程的上下文ClassLoader通常设置为用于加载应用程序的类加载器。java.lang.Thread#setContextClassLoader设置此线程的上下文ClassLoader。上下文ClassLoader可以在创建线程时设置，并允许线程的创建者通过getContextClassLoader方法为在线程中运行的代码提供适当的类加载器，用于加载类和资源。如果存在安全管理器，则会使用其checkPermission方法，传入RuntimePermission的setContextClassLoader权限，以检查是否允许设置上下文ClassLoader。
@CallerSensitive
public ClassLoader getContextClassLoader() {
if (contextClassLoader == null)
return null;
@SuppressWarnings("removal")
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
ClassLoader.checkClassLoaderPermission(contextClassLoader,
Reflection.getCallerClass());
}
return contextClassLoader;
}
public void setContextClassLoader(ClassLoader cl) {
@SuppressWarnings("removal")
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
sm.checkPermission(new RuntimePermission("setContextClassLoader"));
}
contextClassLoader = cl;
}
线程 interrupt
java.lang.Thread#interrupt
中断此线程。除非当前线程自己中断自己，这是始终允许的，否则会调用该线程的checkAccess方法，可能会引发SecurityException异常。
如果此线程在Object类的wait()、wait(long)、wait(long, int)方法的调用中被阻塞，或者在此类的join()、join(long)、join(long, int)、sleep(long)或sleep(long, int)方法的调用中被阻塞，则它的中断状态将被清除，并且它将收到一个InterruptedException异常。
如果此线程在对InterruptibleChannel的I/O操作中被阻塞，则通道将被关闭，线程的中断状态将被设置，并且线程将收到一个ClosedByInterruptException异常。
如果此线程在Selector中被阻塞，则线程的中断状态将被设置，并且它将立即从选择操作中返回，可能带有非零值，就像调用了选择器的wakeup方法一样。
如果以上条件都不满足，则将设置此线程的中断状态。
中断一个未启动的线程可能不会产生任何效果。在JDK参考实现中，中断一个未启动的线程仍然记录了中断请求的发出，并通过interrupted和isInterrupted()方法报告它。
java.lang.Thread#interrupted
测试当前线程是否已被中断。此方法将清除线程的"中断状态"。换句话说，如果连续两次调用此方法，第二次调用将返回false（除非在第一次调用清除了线程的中断状态之后，而第二次调用在检查之前再次中断了当前线程）。
java.lang.Thread#isInterrupted
测试此线程是否已被中断。此方法不会影响线程的"中断状态"。
public void interrupt() {
if (this != Thread.currentThread()) {
checkAccess();
// thread may be blocked in an I/O operation
synchronized (blockerLock) {
Interruptible b = blocker;
if (b != null) {
interrupted = true;
interrupt0(); // inform VM of interrupt
b.interrupt(this);
return;
}
}
}
interrupted = true;
// inform VM of interrupt
interrupt0();
}
public static boolean interrupted() {
Thread t = currentThread();
boolean interrupted = t.interrupted;
// We may have been interrupted the moment after we read the field,
// so only clear the field if we saw that it was set and will return
// true; otherwise we could lose an interrupt.
if (interrupted) {
t.interrupted = false;
clearInterruptEvent();
}
return interrupted;
}
public boolean isInterrupted() {
return interrupted;
}
测试代码如下：
package engineer.concurrent.battle.abasic;
import java.util.concurrent.TimeUnit;
/**
* ThreadInterruptTest
* @author r0ad
* @since 1.0
*/
public class ThreadInterruptTest {
public static void main(String[] args) {
Thread t1 = new Thread() {
@Override
public void run() {
int i = 0;
while(i<10){
i++;
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
};
t1.start();
// 中断该线程
t1.interrupt();
System.out.println("t1 interrupt status " + t1.isInterrupted());
System.out.println("t1 is interrupted and I can work still. ");
// 修改中断状态，但是线程不会继续执行
t1.isInterrupted();
System.out.println("t1 interrupt status " + t1.isInterrupted());
}
}
线程 join
Thread 的 join 方法同样是一个非常重要的方法，与 sleep 一样它也是一个可中断的方法。Thread类通过重载实现了三个函数供多线程开发使用。
java.lang.Thread#join(long)
等待最多millis毫秒，让此线程死亡。0的超时时间意味着永久等待。此实现使用了一个基于this.isAlive条件的this.wait调用循环。当线程终止时，将调用this.notifyAll方法。建议应用程序不要在Thread实例上使用wait、notify或notifyAll。
java.lang.Thread#join(long, int)
等待最多 millis 毫秒加上 nanos 纳秒以使此线程死亡。如果两个参数都是 0，那么意味着永远等待。此实现使用一个循环的 this.wait 调用，条件为 this.isAlive。当一个线程终止时，会调用 this.notifyAll 方法。建议应用程序不要在 Thread 实例上使用 wait、notify 或 notifyAll。
java.lang.Thread#join()
等待此线程终止。调用此方法的行为与调用 join(0) 完全相同。
源码实现如下：
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);
}
当调用join函数之后主线程和子线程的状态切换如下：
- 当调用join()方法时，主线程会进入等待状态，直到子线程执行完毕后才会继续执行。此时主线程的状态为WAITING。
- 如果调用带参数的join()方法，主线程会在等待一段时间后继续执行，而不必一直阻塞。在这种情况下，主线程的状态为TIMED_WAITING。
- 如果子线程已经执行完毕，但是主线程还没有调用join()方法，则子线程的状态为TERMINATED，而主线程的状态为RUNNABLE。
- 如果主线程调用join()方法等待子线程完成执行，而子线程抛出了异常，则主线程会收到异常信息并抛出InterruptedException异常。
测试代码如下：
package engineer.concurrent.battle.abasic;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.stream.IntStream;
/**
* ThreadJoinTest
* @author r0ad
* @since 1.0
*/
public class ThreadJoinTest {
public static void main(String[] args) throws InterruptedException{
List<Thread> threadList = IntStream.range(1, 10).mapToObj(ThreadJoinTest::create).toList();
threadList.forEach(Thread::start);
for(Thread thread : threadList){
thread.join();
}
IntStream.range(1, 10).forEach((i)-> {
System.out.println("thread " + Thread.currentThread().getName() + " # "+ i );
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
});
}
/**
* 线程创建函数
* @param index
* @return
*/
private static Thread create(int index) {
return new Thread(() -> {
int i = 0;
while (i++<10) {
System.out.println("thread " + Thread.currentThread().getName() + " # "+ i );
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
}
}
通过观察输出结果发现，join之后的线程全部结束后才会执行输出main线程的内容。
thread Thread-0 # 10
thread Thread-1 # 10
thread Thread-7 # 10
thread Thread-6 # 10
thread main # 1
thread main # 2
thread main # 3
关闭线程
在JDK 17中，线程停止的情况和函数有以下几种：
- 自然结束：线程执行完run()方法后，线程会自然结束并进入终止状态。
- 线程被中断：可以使用Thread类的interrupt()方法来中断线程。当一个线程调用另一个线程的interrupt()方法时，被调用线程会收到一个中断信号，并且中断状态会被设置为true。中断状态可以通过Thread类的isInterrupted()方法来查询。线程可以在适当的时机检查中断状态，如果中断状态为true，则可以选择安全地终止线程的执行。
- 使用标志位停止线程：可以在多线程程序中定义一个标志位，当标志位为true时，线程停止执行。线程可以周期性地检查该标志位，如果标志位为true，则主动结束线程的执行。
- 使用Thread类的stop()方法（已废弃）：Thread类提供了一个stop()方法，可以立即停止线程的执行。但是这个方法已经被标记为不安全和不推荐使用，因为它可能导致线程在不可预料的位置停止，造成数据不一致或其他问题。
tips native函数
Java中的native关键字用于表示某个方法的实现是由本地代码（C、C++等）提供的。这些本地方法可以直接在Java程序中调用，而无需了解其底层实现。
在Java中，使用native关键字定义本地方法时，不需要提供方法体。例如：
public native void myNativeMethod();
在上面的示例中，myNativeMethod()被定义为本地方法，并且没有提供方法体。在运行时，Java虚拟机将查找本地方法的实现，如果找不到，则会抛出UnsatisfiedLinkError异常。
要调用本地方法，需要使用native方法的外部实现。这通常涉及到将Java代码与本地代码库进行链接。可以使用Java本机接口（JNI）来实现这一点。
参考
- 《Java高并发编程详解：多线程与架构设计》
- Java Thread Doc
关于作者
来自一线全栈程序员nine的八年探索与实践，持续迭代中。欢迎关注“雨林寻北”或添加个人卫星codetrend（备注技术）。
1475
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
