线程Thread中常用API讲解

sleep方法

·
Thread类中的静态方法，线程中的sleep方法用来指定线程休眠的时间长度，当线程执行到这段代码时，线程将会进行等待，在等待期间，该线程持有monitor锁，也就是说此时它仍具有cpu持有权，但是并不进行执行逻辑。通俗一点就是可能你租了辆共享单车，但是你中途有事先把它锁上晚点再回来继续使用，在你离开的这段时间，你并没有使用这辆车，但是车被你上锁了，上锁期间只有你拥有这辆车的使用权。

currentThread方法

这是也是一个静态方法，用于获取当前的线程实例。

setPriority方法

该方法用于设置线程的优先级，线程的默认优先级为5，当cpu资源紧张时，优先级高的线程获得cpu资源的概率更大，当然这只是概率比较大，并不是说优先级高的就一定能抢到cpu资源。如果cpu资源较为空闲的话，那此时优先级的 作用就体现不出来了。

yield方法

yield在英文中的原意是让路，这意味着在多线程中当前线程原意暂时放弃cpu的资源，当然这只是给cpu一个提示，当cpu资源并不紧张的话，cpu会选择无视yield提醒。如果cpu没有无视yield，那么执行yield的线程就会从RUNNING运行态转换为RUNNABLE就绪态，而其他本就处于RUNNABLE就绪态的线程便会开始抢占cpu资源。

interrupt方法

interrupt的意思是打断，当然这里不是指打断线程，而是指中断方法，例如可中断线程的休眠。那么问题来了，如果当前线程没有可中断的方法会发生什么，这里可以小小的测试一下。

public class InterruptDemo1 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println("当前线程处于打断状态："+Thread.currentThread().isInterrupted());
            }
        });
        thread.start();
        //主线程休眠一段时间用于thread线程的启动
        Thread.sleep(3);
        thread.interrupt();
    }
}

该程序执行的结果如下：

程序的大致执行流程：

1. 创建线程，通过start开启线程
2. 主线程休眠一段时间用于thread的启动，此期间若thread执行代码逻辑，那么Thread.currentThread().isInterrupted()将输出false
3. 主线程休眠一段时间后执行thread.interrupt(),此时thread线程中断，Thread.currentThread().isInterrupted()为true,若没有调用可中断方法或者清除interrupted标识，这个值将一直是true.

现在再看一下在执行可中断方法是执行interrupt会发生什么：

public class InterruptDemo2 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            System.out.println("开始执行线程内容");
            for (int i = 0; i < 100; i++) {
                System.out.println("当前线程处于打断状态：" + Thread.currentThread().isInterrupted());
                //System.out.println("当前线程处于打断状态：" + Thread.interrupted());
                try {
                    System.out.println("线程休眠");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    System.out.println("线程睡眠被打断！！！");
                }
            }
        });
        thread.start();
        Thread.sleep(1);
        thread.interrupt();
    }
}

改程序执行的结果如下：

这边结果我还是只展示了一部分，下面的结果都是一样的，可以看到，Thread.currentThread().isInterrupted()的结果一直都是false,这是为什么 ？
下面继续分析一下执行流程：

1. 通过start开启thread线程，此时由于还没有执行interrupt，线程打断状态为false
2. thread进入休眠
3. 主线程执行到thread.interrupt(),thread的休眠中断，Thread.currentThread().isInterrupted()这个时候应该为true,但由于thread线程会自动捕获捕获中断的信号，得到信号后将清除interrupted的标识，因此这个值一直都是false.

最后再来对比一下两个方法isInterrupted和interrupted，可以先看一下源码：

• isInterrupted方法

public boolean isInterrupted() {
        return isInterrupted(false);
    }

• interrupted方法

public static boolean interrupted() {
        return currentThread().isInterrupted(true);
    }

这两个方法最终调用的方法都是native函数isInterrupted，只不过设置的值不一样，具体的源码我们是看不到了，不过这个方法传入的参数名叫做ClearInterrupted，其实就是是否清除标记。对于isInterrupted的测试在InterruptDemo1已经做过了，这里主要测试一下interrupted：

public class InterruptDemo1 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                //System.out.println("当前线程处于打断状态："+Thread.currentThread().isInterrupted());
                System.out.println("当前线程处于打断状态："+Thread.interrupted());
            }
        });
        thread.start();
        //主线程休眠一段时间用于thread线程的启动
        Thread.sleep(3);
        thread.interrupt();
    }
}

从结果中可以看出，中间得到了一次true后都是false，其实就是Thread.interrupted()获取到当前线程中断状态，如果为false将重置状态为false，相对而言isInterrupted则不会，它只是获取状态。
最后总结一下吧：

方法名	特点
interrupt	将调用该方法所表示的线程中断，其实只是做上一个中断标记，并不是真正的停止线程
isInterrupted	获取调用该方法所表示的线程中断状态
interrupted	获取调用该方法所表示的线程中断状态,并清除中断标记

join方法

通过join方法可以实现线程的并行，如果两个线程分别做两个不同的事情，并且互不影响就可以使用join。现在先来看个小案例：

public class JoinDemo {
    public static void main(String[] args) {
        Thread test1 = getTest("1");
        Thread test2 = getTest("2");
        Thread thread = new Thread(() -> System.out.println("任务全部完成"));
        test1.start();
        test2.start();
        thread.start();
    }
    public static Thread getTest(String name){
        return new Thread(()->System.out.println("线程"+name+"完成。。。。"));
    }
}

按照我们预期的想法，test1和test2都分别完成后才算是任务全部完成，然而事实并不是这样的，可能thread优先抢到cpu资源，那就直接输出了“任务全部完成”，很显然这不是我们想要的。现在把代码改一下：

public class JoinDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread test1 = getTest("1");
        Thread test2 = getTest("2");
        Thread thread = new Thread(() -> System.out.println("任务全部完成"));

        test1.start();
        test2.start();
        test1.join();
        test2.join();

        thread.start();
    }
    public static Thread getTest(String name){
        return new Thread(()->System.out.println("线程"+name+"完成。。。。"));
    }
}

先看下输出结果：

此时test1和test2会进行join操作，而主线程会进入阻塞状态直到test1和test2执行完逻辑代码后，主线程继续执行。当然test1和test2的顺序已经是随机的，看哪个先抢到cpu资源吧。