java 22

线程休眠（让线程休息一会再运行）
　　public static void sleep(long millis)

在自定义线程类中添加该方法。

更改后，运行测试类，结果就是每执行完一轮，就休息1秒（这里设置的是休眠1秒），再进行一轮。

一轮：（如果测试类调用了3个线程，那么就是随机运行3次为一轮）

如：

　　哈士奇:1,日期：Wed Oct 05 21:01:19 CST 2016
　　短尾猫:1,日期：Wed Oct 05 21:01:19 CST 2016
　　萨摩耶:1,日期：Wed Oct 05 21:01:19 CST 2016

休息1秒，继续：

　　萨摩耶:2,日期：Wed Oct 05 21:01:20 CST 2016
　　哈士奇:2,日期：Wed Oct 05 21:01:20 CST 2016
　　短尾猫:2,日期：Wed Oct 05 21:01:20 CST 2016

public class ThreadSleep extends Thread {
    @Override
    public void run() {
        for (int x = 0; x < 100; x++) {
            System.out.println(getName() + ":" + x + ",日期：" + new Date());
            // 睡眠
            // 稍微休息1秒钟
            try {
                Thread.sleep(1000);//由于父类没有抛出异常，所以得try{}catch(){}
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

线程加入
　　public final void join()：等待该线程终止。 这个方法是在测试类上添加的

也就是说，得等这个线程运行结束，别的线程才能运行

以下代码就是，哈士奇先数完0-99，萨摩耶和短尾猫才能运行。。。二哈真6

public class ThreadJoinDemo {
    public static void main(String[] args) {
        ThreadJoin tj1 = new ThreadJoin();
        ThreadJoin tj2 = new ThreadJoin();
        ThreadJoin tj3 = new ThreadJoin();

        tj1.setName("哈士奇");
        tj2.setName("萨摩耶");
        tj3.setName("短尾猫");

        tj1.start();
        try {
            tj1.join();//由于父类没有抛异常，所以得try{}catch(){}
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        tj2.start();
        tj3.start();
    }
}

线程礼让
　　public static void yield(); ：暂停当前正在执行的线程对象，并执行其他线程。

让多个线程的执行更和谐，但是不能靠它保证全部的和谐（即是哈士奇运行一次，萨摩耶运行一次，短尾猫运行一次）。

这个方法不能完全保证，有可能哈士奇连续运行几次。二哈继续6。。

该方法在测试类中添加：

public class ThreadYield extends Thread {
    @Override
    public void run() {
        for (int x = 0; x < 100; x++) {
            System.out.println(getName() + ":" + x);
            Thread.yield();
        }
    }
}

守护线程
　　public final void setDaemon(boolean on):将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。 该方法必须在启动线程前调用。

通俗易懂地说：守护线程是用来保护别的非守护线程的，如果其它非守护线程都停止了，守护线程自身也必须停止

（保护的人挂了，守护者也得挂，不过守护者得到消息再挂，所以受保护者挂了以后，守护者会继续执行几次再挂）

代码：

//这个代码中，刘备一运行完毕，张飞关羽跟着再运行几次，就停止
public class ThreadDaemonDemo {
    public static void main(String[] args) {
        ThreadDaemon td1 = new ThreadDaemon();
        ThreadDaemon td2 = new ThreadDaemon();

        td1.setName("关羽");
        td2.setName("张飞");

        // 设置守护线程
        td1.setDaemon(true);
        td2.setDaemon(true);

        td1.start();
        td2.start();

        Thread.currentThread().setName("刘备");
        for (int x = 0; x < 5; x++) {
            System.out.println(Thread.currentThread().getName() + ":" + x);
        }
    }
}

再来个配图：坦克大战

中断线程

public final void stop():让线程停止，过时了，但是还可以使用。

替代stop的：

public void interrupt():中断线程。 把线程的状态终止，并抛出一个InterruptedException。

自定义多线程类：

public class ThreadStop extends Thread {
    @Override
    public void run() {
        System.out.println("开始执行：" + new Date());

        // 休眠10秒钟
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            // e.printStackTrace();
            System.out.println("线程被终止了");
        }

        System.out.println("结束执行：" + new Date());
    }
}

测试类：

public class ThreadStopDemo {
    public static void main(String[] args) {
        ThreadStop ts = new ThreadStop();
        try {
            Thread.sleep(3000);
            // ts.stop();  //过了3秒后，关闭ThreadStop线程，
            ts.interrupt(); //中断线程。 把线程的状态终止，并抛出一个InterruptedException
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public void interrupt():的执行结果：

　　　　开始执行：Wed Oct 05 21:58:44 CST 2016
　　　　线程被终止了
　　　　结束执行：Wed Oct 05 21:58:47 CST 2016