如何优雅地停下线程？除了这两种，你还能说出一种算我输

　　前言
　　今天主要来聊一聊如何优雅地停下线程。
　　在开始之前，我们可以思考一下，如何能够让线程停下？
　　通过查阅JDK，我们不难发现Thread为我们提供了一个stop方法，只要使用stop方法，就立即停止线程，但是发现stop()方法被标注为废弃的方法，因为这个方法会强行把执行到一半的线程终止，可能会引发一些数据不一致或者我们没发预估的问题。
　　除了stop()方法，我能想到的方案还有两个，
　　方案一：使用volatile标记位，利用其可见性
　　方案二：调用Thread的方法interrupted方案实现方案一：使用volatile标记位，利用其可见性
　　通过代码我们来看下方案一，这是一个很经典的生产者和消费者模式。
　　生产者Demo//生产者 class Producer implements Runnable {     public volatile boolean canc = false;      private Product product;      Producer(Product product) {         this.product = product;     }      @Override     public void run() {         try {             while (!canc) {                 try {                     //Thread.sleep(1000);                     product.put(＂iphone6s＂);                     System.out.println(＂put:＂ + Thread.currentThread().getName());                 } catch (InterruptedException e) {                     e.printStackTrace();                 }             }         } catch (Exception ex) {             ...         } finally {             System.out.println(＂结束＂);         }     } }
　　消费者Demo//消费者 class Consumer implements  Runnable{     private Product product;      Consumer(Product product) {         this.product = product;     }      @Override     public void run() {         while (Math.random() > 0.9){             try {                 Thread.sleep(1000);                 product.take(＂iPhone6s＂);                 System.out.println(＂take:＂+Thread.currentThread().getName());             } catch (InterruptedException e) {                 e.printStackTrace();             }         }     } }
　　调用生产者和消费者public static void main(String[] args) {     ArrayBlockingQueue queue = new ArrayBlockingQueue(1);     Product product = new Product(queue);     Producer producer = new Producer(product);     Consumer consumer = new Consumer(product);     Thread c1 = new Thread(consumer);     Thread p1 = new Thread(producer);     p1.start();     try {         Thread.sleep(500);     } catch (InterruptedException e) {         e.printStackTrace();     }     c1.start();     System.out.println(＂消费者不需要更多数据了。＂);     producer.canc = true;     System.out.println(producer.canc);     System.out.println(p1.getState()); }
　　场景一： 我们把消费者和生产者的线程都开起来，生产者生产一个产品，消费者都会消费一个产品，这个时候volatile的值，在下一次的轮询中值已经变成了true，就跳出while循环，线程就停止，这个场景下volatile就适用了。
　　场景二： 我们将消费者线程不启动，只生产不消费。 理论上我们期待的结果应该也是值变成true，跳出while循环，线程停止。
　　结果打印：Put a iphone6s put:Thread-2 消费者不需要更多数据了。 valatile的值： true 线程状态：WAITING
　　根据打印的结果我们会观察到他没有输出结束的语句，
　　我们看到了生产者生产了产品，valatile也修改了值，但是线程却没有结束，
　　这主要的原因是因为，生产者执行了product.put(＂iphone6s＂)，没有被消费，造成了阻塞，在它唤醒之前，
　　无法进入下一次的轮询判断。造成了值修改了，却没有做出相应处理。
　　我们发现在消费的时候，take方法内部会触发唤醒，当检测到线程已经停止，则抛出InterruptedException异常。开源码说话，可以看到dequeue，唤醒了线程。public E take() throws InterruptedException {     final ReentrantLock lock = this.lock;     lock.lockInterruptibly();     try {         while (count == 0)             notEmpty.await();         return dequeue();     } finally {         lock.unlock();     } }  public final void acquireInterruptibly(int arg)         throws InterruptedException {     if (Thread.interrupted())         throw new InterruptedException(); }  private E dequeue() {     ...     //释放     notFull.signal();     return x; } 二、方案二：调用Thread的方法interruptedstatic class CreateRunable implements Runnable {     public CreateRunable(int i) {         this.i = i;     }      private int i;      public int getI() {         return i;     }      public void setI(int i) {         this.i = i;     }      @Override     public  void run() {         synchronized (this){             while ( !Thread.currentThread().isInterrupted() ){                 System.out.println(＂Runable接口，实现线程＂+i++);             }         }     } }Thread createThread = new Thread(new CreateRunable(0)); createThread.start(); Thread.sleep(5); createThread.interrupt();
　　休眠5毫秒后，该线程检查到了中断信号，就会停止线程。
　　那如果任务正在休眠状态，线程会如何处理呢@Override public  void run() {     synchronized (this){         while ( !Thread.currentThread().isInterrupted() ){             try {                 Thread.sleep(10000);             } catch (InterruptedException e) {                 e.printStackTrace();             }             System.out.println(＂Runable接口，实现线程＂+i++);         }     } }
　　抛出异常，同时清除中断状态，线程会继续执行Runable接口，实现线程0 java.lang.InterruptedException: sleep interrupted     at java.lang.Thread.sleep(Native Method)     at main.Thread.threadStartThreeWays$CreateRunable.run(threadStartThreeWays.java:48)     at java.lang.Thread.run(Thread.java:748) Runable接口，实现线程1 Runable接口，实现线程2 Runable接口，实现线程3 总结
　　我们在这里就不说Stop()方法，因为他太暴力了，不够优雅。这里的优雅指的是可以让线程有时间做好收尾工作，避免数据的错乱。 优雅停下线程的方式主要有两种方案一：使用volatile标记位。方案二：调用Thread的方法interrupted。
　　通过上面的demo案例，我们可以看到使用方案一的volatile，在某一些特殊的场景下，会发生不能关闭线程的情况。
　　所以volatile是不够全面的。方案二则是一种更优的选择。