关于java线程中stop interrupt daemon wait notify

一。关于终止线程stop与interrupt

　　一般来说，线程执行结束后就变成消亡状态，乍看之下我们并不需要人为进行干预(人为停止线程)，不过凡事都有例外吧，在服务器或者其他应用场景下，线程为了提供服务而一直在不停的运转，因此必要时刻我们还需“人为干涉的”。

　　通常情况下，终止线程有两种方式：stop与interrupt

　　1) stop:暴力的停止线程(不管线程执行到哪段代码，立刻干掉)，这个方法因为过于暴力会导致安全问题，因此JDK不推荐使用。

　　2) interrupt:优雅停止，调用该方法会通知线程可以进行停止操作了，此时线程只是变成可停止状态(thread.isInterrupted的值为true)，实际上并没有停止

　　请看下段代码：

　　

package com.bdqn.lyrk.basic;

/**
 * 一个线程设置共享变量的值，保持ID与name值相同
 * 另外一个线程读取共享变量的值，发现ID与name值不同时打印
 *
 * @author chen.nie
 * @date 2018/1/30
 **/
public class StopThreadUnsafe {

    public static User user = new User();

    public static class User {
        private int id;
        private String name;

        public int getId() {
            return id;
        }

        public void setId(int id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public User() {
            id = 0;
            name = "0";
        }

        @Override
        public String toString() {
            return "User [id=" + id + ",name=" + name + "]";
        }
    }

    public static class ChangeObjectThread extends Thread {

        @Override
        public void run() {
            while (true) {
                synchronized (user) {
                    if (Thread.currentThread().isInterrupted()) {
                        break;
                    }
                    int i = (int) System.currentTimeMillis() / 1000;
                    user.setId(i);
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                    user.setName("" + i);

                }
                Thread.yield();
            }
        }
    }

    public static class ReadObjectThread extends Thread {

        @Override
        public void run() {
            while (true) {
                synchronized (user) {
                    if (user.getId() != Integer.parseInt(user.getName())) {
                        System.out.println(user);
                    }
                }
                Thread.yield();
            }
        }
    }
}

　　Main方法：

package com.bdqn.lyrk.basic;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        new StopThreadUnsafe.ReadObjectThread().start();
        while (true) {
            StopThreadUnsafe.ChangeObjectThread thread = new StopThreadUnsafe.ChangeObjectThread();
            thread.start();
            Thread.sleep(200);
            thread.stop();
           // thread.interrupt();
        }
    }
}

　　此时调用stop终止线程时,得到如下结果

　　

User [id=1197577,name=1197576]
User [id=1197577,name=1197576]
User [id=1197577,name=1197576]
User [id=1197577,name=1197576]
User [id=1197578,name=1197577]

原因很简单：stop方法会释放对象锁，并终止线程，当线程还没有与name赋值时，已经被干掉了因此其他线程在读取时，很有可能读到NAME与ID值不一致的情况

二。守护线程Daemon

     守护线程顾名思义，是系统的守护者，这个线程为系统的运行默默提供服务，当系统任务运行完毕，守护线程也就完成使命了，比如说垃圾回收线程，JIT线程都是守护线程，设置守护线程的方式：在调用start方法前，通过线程对象.setDaemon(true)

代码如下：

package com.bdqn.lyrk.basic;

public class DaemonDemo {
    public static class DaemonT extends Thread {
        @Override
        public void run() {
            while (true){
                System.out.println("I am alive");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        DaemonT daemonT = new DaemonT();
        daemonT.setDaemon(true);
        daemonT.start();
        Thread.sleep(5000);
    }
}

运行结果

I am alive
I am alive
I am alive
I am alive
I am alive

Process finished with exit code 0

我们可以看到，当主线程执行完毕后，守护线程也随之结束

三。wait与notify

　　wait与notify是多线程协同工作的最基本手段，可是这两个方法属于Object的方法，当需要使用wait和notify时，必须配合synchronized使用，此时调用wait方法，当前线程会进入等待队列并释放当前的对象锁，直到线程被唤醒(notify)，notify方法会随机唤醒一个在等待队列中的线程，notifyAll方法则唤醒所有在等待队列中的线程

代码示例:

package com.bdqn.lyrk.basic;

public class SimpleWN {
    public static final Object object = new Object();

    public static class T1 extends Thread {

        @Override
        public void run() {
            synchronized (object) {
                System.out.println("开始执行线程...");
                try {
                    object.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("结束执行线程...");
            }
        }
    }

    public static class T2 extends Thread {
        @Override
        public void run() {
            synchronized (object) {
                System.out.println("5秒后准备唤醒线程..");
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                object.notify();
            }
        }
    }

    public static void main(String[] args) {
        T1 t1 = new T1();
        T2 t2 = new T2();
        t1.start();
        t2.start();
    }
}

输出内容：

开始执行线程...
5秒后准备唤醒线程..
结束执行线程...

Process finished with exit code 0

注意以下几点： 

1）当线程T1被notify过后，也必须要重新获取对象锁，才能够继续执行

2）sleep也能达到wait的效果，但是唯一区别时，sleep时并不会释放对象锁，因此其他线程并没有得到执行的机会