[Java线程]sleep，join，interrupt解析

今天开始深入学习Java线程，就先从sleep，join，interrupt这3个函数开始吧。

先来看一下这3个函数的功能。

1，sleep：是Thread类的一个静态方法，作用是让当前线程阻塞，该函数的参数就是阻塞时间，以毫秒为单位。
2，interrupt：中断线程。
3，join：作用是让两个线程同步。例如：有A,B两个线程，如果在B中调用了A.join()的话，则表示A线程执行完了才开始执行B线程。

废话不说了，边看例子变学习吧。

========================sleep篇========================

例子所要实现功能：启动一个线程，每隔一秒钟执行一次打印

下面看代码：

package lxcjie;

import java.util.Calendar;

public class SleepDemo extends Thread {

    public static void main(String[] args) {
        //创建线程
        SleepDemo sleep = new SleepDemo();
        //线程开始执行
        sleep.start();
    }

    public void run() {
        try {
            //做一个无限循环，每一秒输出一次内容
            while (true) {
                //线程中断1秒钟后继续执行
                sleep(1000);
                System.out.println(getTime() + "  " + getName() + " Is Running");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //为了更容易理解，在打印内容前面加上当前时间
    private String getTime() {
        Calendar rightNow = Calendar.getInstance();
        rightNow.setTimeInMillis(System.currentTimeMillis());
        return rightNow.get(Calendar.HOUR) + ":"
                + rightNow.get(Calendar.MINUTE) + ":"
                + rightNow.get(Calendar.SECOND);
    }
}

看看执行结果吧：

可以看出，正如我们所期待的，每隔一秒钟打印了一次内容，OK。

=================interrupt篇=================

例子所要实现功能：打印5次信息后中断线程

下面看代码：

package lxcjie;

public class InterruptDemo extends Thread {

    public static void main(String[] args) throws InterruptedException {
        //创建线程
        InterruptDemo sleep = new InterruptDemo();
        //启动线程
        sleep.start();

        //主线程中断5秒钟
        Thread.sleep(5000);
        //sleep子线程被中断
        sleep.interrupt();
    }

    public void run() {
        try {
            //做一个无限循环，每一秒打印一条信息
            while (true) {
                sleep(1000);
                System.out.println(getName() + " Is Running");
            }
        } catch (InterruptedException e) {
            //被终端以后打印一条信息
            System.out.println(getName() + " Is Interrupted");
            return;
        }
    }
}

看看执行结果吧：

OK，打印5次信息后成功被中断。

========================join篇========================

sleep和interrupt函数属于线程中的比较直观的两个函数，看例子应该就能理解了。
对于join这个函数，起码对于我来说，比较抽象，所以下面具体分析一下。

就像前面所说的，join函数的功能就是让两个线程保持同步，说白了就是给两个线程加一个执行顺序。
更啰嗦一点，就是说如果不加join函数，A和B两个线程是同时执行的，加了join函数，A和B两个线程就按
程序指定的顺序依次执行了。

为了验证，我们先看个例子，看看没join函数的时候会发生什么：

package lxcjie;

public class JoinDemo {
    public static void main(String[] args) throws InterruptedException {
        //创建SleepThread子线程
        SleepThread sleep = new SleepThread("MySleepThread");
        //创建JoinThread子线程，同时把上面的SleepThread线程作为参数传入
        JoinThread join = new JoinThread("MyJoinThread", sleep);
        
        //启动2个子线程
        sleep.start();
        join.start();

        //主线程中断3秒钟
        Thread.sleep(3000);
        //SleepThread子线程被中断
        sleep.interrupt();
    }
}

//创建一个线程类，作用如下：
//1，每个1秒钟打印一条信息
//2，如果该线程被中断，则打印被中断的信息
class SleepThread extends Thread {

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

    public void run() {
        while (true) {
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                System.out.println(">>> " + getName() + " Is Interrupted");
                return;
            }
            System.out.println(getName() + " Is Running");
        }
    }
}

//创建另外一个线程类，作用如下：
//1，调用join函数，与传入的SleepThread线程保持同步
//   也就是说在线程SleepThread执行完毕后，JoinThread才继续执行
//2，每个1秒钟打印一条信息
//3，如果该线程被中断，则打印被中断的信息
class JoinThread extends Thread {
    private SleepThread sleep = null;

    //SleepThread作为构造函数的参数，用于线程同步操作
    public JoinThread(String name, SleepThread sleep) {
        super(name);
        this.sleep = sleep;
    }

    public void run() {
        try {
            //为了更直观的理解join函数，我们先把它注释掉，看看会发生什么事情
            //this.sleep.join();

            while (true) {
                sleep(1000);
                System.out.println(getName() + " Is Running");
            }
        } catch (InterruptedException e) {
            System.out.println("Interrupted");
        }
    }
}

到底发生什么了，我们看一下执行结果：

可以看到，两个线程是同时开始的，MySleepThread线程被中断后，只剩MyJoinThread线程执行了。
也就是说，两个线程的执行是完全没有关系的。

那下面我们把注释部分去掉：

package lxcjie;

public class JoinDemo {
    public static void main(String[] args) throws InterruptedException {
        //创建SleepThread子线程
        SleepThread sleep = new SleepThread("MySleepThread");
        //创建JoinThread子线程，同时把上面的SleepThread线程作为参数传入
        JoinThread join = new JoinThread("MyJoinThread", sleep);
        
        //启动2个子线程
        sleep.start();
        join.start();

        //主线程中断3秒钟
        Thread.sleep(3000);
        //SleepThread子线程被中断
        sleep.interrupt();
    }
}

//创建一个线程类，作用如下：
//1，每个1秒钟打印一条信息
//2，如果该线程被中断，则打印被中断的信息
class SleepThread extends Thread {

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

    public void run() {
        while (true) {
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                System.out.println(">>> " + getName() + " Is Interrupted");
                return;
            }
            System.out.println(getName() + " Is Running");
        }
    }
}

//创建另外一个线程类，作用如下：
//1，调用join函数，与传入的SleepThread线程保持同步
//   也就是说在线程SleepThread执行完毕后，JoinThread才继续执行
//2，每个1秒钟打印一条信息
//3，如果该线程被中断，则打印被中断的信息
class JoinThread extends Thread {
    private SleepThread sleep = null;

    //SleepThread作为构造函数的参数，用于线程同步操作
    public JoinThread(String name, SleepThread sleep) {
        super(name);
        this.sleep = sleep;
    }

    public void run() {
        try {
            //注释去掉了，看看结果！！
            this.sleep.join();

            while (true) {
                sleep(1000);
                System.out.println(getName() + " Is Running");
            }
        } catch (InterruptedException e) {
            System.out.println("Interrupted");
        }
    }
}

我们再来看看加上join后的结果：

我们看到了什么？开始的时候只有MySleepThread执行了，等到MySleepThread被中断后，
MyJoinThread才被执行。看到这里，join函数的作用就很直观了。

好了，今天就学习到这里，顺便跟大家分享一下学习结果。

继续努力学习中。。。