线程间通信与协作方式之——基本方式

在上篇文章中，我讲解了关于并发主题的一些基础知识，使大家对于线程有了一个初步的概念。那么今天我就来为大家讲解一下线程之间是如何通信以及它们是怎样协作的。

1.Thread.join()方法

 想象一下有两个线程A、B，线程A需要等待线程B执行完毕后才能继续执行，那么此时就可以用join方法来实现。

public class JoinThread {

    public static void main(String[] args) {
        System.out.println("main thread,continue when join thread finish.........");
        try {
            NeedJoinThread nj = new NeedJoinThread();
            nj.start();
            nj.join();
        } catch (InterruptedException e) {
            System.out.println("catch exception in main thread.........");
        }
        System.out.println("main thread,join thread is finish, i can continue my job........");
    }
}

class NeedJoinThread extends Thread{

    @Override
    public void run() {
        try {
            Thread.sleep(10000L);
            System.out.println("i'm join thread, i'm finish my job..........");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

从上面的代码可以看出，模拟了NeedJoinThread执行任务需要10s，而在主线程中调用了 nj.join() 后，就会让 NeedJoinThread  先执行，主线程会等待其执行完毕后再继续执行后续代码。

看一下Join方法的源码：

    public final synchronized void join(long millis)
    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;

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

        if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

可以看到底层其实就是wait-notify机制（后面会讲）。这里有一个参数millis，指的是设置超时时间。如果没传这个参数，那么当前线程会无限等待，直到join进来的线程执行完毕调用notify唤醒当前线程后，当前线程才会继续执行任务；

否则传了这个参数，当前线程就会在最多等待相应的millis毫秒后继续执行任务，而不再管join进来的线程是否已执行完毕任务。

2.Thread.yield()方法

想象一下A、B两个线程，如果在A执行过程中需要让B线程也有执行机会，但对两个线程的执行顺序并无严格要求的情况下，可以使用Thread.yield()方法。

public class YieldThread {

    public static void main(String[] args) {
        NeedYieldThread ny = new NeedYieldThread();
        ny.start();
    }
}

class NeedYieldThread extends Thread{

    @Override
    public void run() {
        long beginTime = System.currentTimeMillis();
        int count = 0;
        for (int i = 0; i < 1000000; i++)
        {
            Thread.yield();
            count = count + i + 1;
        }
        long endTime = System.currentTimeMillis();
        System.out.println("Cost：" + (endTime - beginTime) + "millisecond！");
    }
}

可以多运行几次这段代码，会发现每次输出的结果都是不一样的。这证明了调用了yield方法的线程会让出CPU执行权，但是让出的时间是不确定的。有可能刚刚让出执行权马上又抢到，也有可能让出好一会儿后才抢到执行权。

3.Thread.sleep(millinSeconds)方法

 当需要让一个正在运行的线程暂停一段时间后再继续执行，那么就可以使用Thread.sleep(millinSeconds)这个方法。

public class SleepThread {

    public static void main(String[] args) {
        try {
            System.out.println("main thread start........");
            Thread.sleep( 5000L);
            System.out.println("after five senconds, main thread end.......");
        } catch (InterruptedException e) {
            System.out.println("catch exception.........");
        }
    }
}

主线程会暂停5秒，然后打印end。

注意JDK源码中sleep方法的注释有这么一句话“The thread does not lose ownership of any monitors”，意思就是调用sleep方法的线程不会让出锁的拥有权，只会让出CPU执行权，这一点要牢记。

4.interrupt、interrupted、isInterrupted的区别

上一篇文章已经介绍过了中断机制，那么java的api中有这三个方法并且它们长得很相似，下面就讲一下它们各自的作用：

（1）interrupt方法：对调用该方法的线程设置中断标识。注意，该方法只会打上中断标识，并不是强行让当前线程终止。具体什么时候终止是由线程自己决定的，无法进行人为干预。

（2）interrupted方法：检测当前线程是否已经中断，并且会清除中断标识。因为这个特性，所以当线程调用该方法之后如果再一次调用该方法，那么结果必定为false（因为第一次调用已经清除了中断标识）

（3）isInterrupted方法：同样用来检测当前线程是否已经中断，唯一和interrupted方法不同的是该方法不会清除中断标识。

线程间的基本通讯方式大概就这些，下篇文章会讲解线程间协作非常经典的方式—— wait-notify机制。