Java并发：结束线程

 import java.util.ArrayList;
 import java.util.List;
 import java.util.Random;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
 
 //所有入口的总人数
 class Count {
	 //count 会并发访问，所以 get/set 需要 synchronized 锁起来
	 private int count = 0;
	 private Random rand = new Random(47);
 
	 //如果去掉 synchronized 那么其中的 temp 和 Thread.yield()会
	 //大大增加 increment 失败的几率（也就是并发修改）
	 public synchronized int increment() {
		 int temp = count;
		 if (rand.nextBoolean()) {
			 Thread.yield();
		 }
		 return (count = ++temp);
	 }
 
	 public synchronized int value() {
		 return count;
	 }
 }
 
 //每个入口通过 number 各自统计通过当前门的人数
 class Entrance implements Runnable {
 
	 private static Count count = new Count();
	 private static List<Entrance> entrances = new ArrayList<Entrance>();
	 private int number = 0;
	 private final int id;
	 private static volatile boolean canceled = false;
 
	 public static void cancel() {
		 canceled = true;
	 }
 
	 public Entrance(int id) {
		 this.id = id;
		 entrances.add(this);
	 }
 
	 // run()的任务就是递增入口人数和总人数，验证 count 的总数是正确的。然后休眠100ms
	 @Override
	 public void run() {
		 while (!canceled) {
			 synchronized (this) {
				 ++number;
			 }
			 System.out.println(this + " Total: " + count.increment());
			 try {
				 TimeUnit.MILLISECONDS.sleep(100);
			 } catch (InterruptedException e) {
				 System.out.println("sleep interrupted");
			 }
		 }
		 System.out.println("stopping " + this);
	 }
 
	 public synchronized int getValue() {
		 return number;
	 }
 
	 public String toString() {
		 return "Entrace " + id + ": " + getValue();
	 }
 
	 public static int getTotalCount() {
		 return count.value();
	 }
 
	 public static int sumEntrances() {
		 int sum = 0;
		 for (Entrance entrance : entrances) {
			 sum += entrance.getValue();
		 }
		 return sum;
	 }
 }
 
 // 5个门，运行3s 后通过 exec.shutdown()发送 interrupt()中断
 public class OrnametalGarden {
	 public static void main(String[] args) throws InterruptedException {
		 ExecutorService exec = Executors.newCachedThreadPool();
		 for (int i = 0; i < 5; i++) {
			 exec.execute(new Entrance(i));
		 }
		 TimeUnit.SECONDS.sleep(3);
		 Entrance.cancel();
		 exec.shutdown();
		 //等待超时时间250ms 后返回 boolean 是否任务终结
		 if (!exec.awaitTermination(250, TimeUnit.MILLISECONDS)) {
			 System.out.println("some tasks were not terminated");
		 }
		 System.out.println("Total: " + Entrance.getTotalCount());
		 System.out.println("Sum of Entrances: " + Entrance.sumEntrances());
	 }
 }

 package concurrency;
 
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
 
 // Sleep()阻塞
 class SleepBlocked implements Runnable {
	 @Override
	 public void run() {
		 try {
			 TimeUnit.SECONDS.sleep(100);
		 } catch(InterruptedException e) {
			 System.out.println("InterruptedException!");
		 }
		 System.out.println("Exiting SleepBlocked.run()\n");
	 }
 }
 
 // IO阻塞
 class IOBlocked implements Runnable {
	 private InputStream in;
	 public IOBlocked(InputStream in) {
		 this.in = in;
	 }
	 @Override
	 public void run() {
		 try {
			 System.out.println("Waiting for read():");
			 in.read();
		 } catch(IOException e) {
			 if(Thread.currentThread().isInterrupted()) {
				 System.out.println("Interrupted from blocked I/O");
			 } else {
				 throw new RuntimeException(e);
			 }
		 }
		 System.out.println("Exiting IOBlocked.run()\n");
	 }
 }
 
 // 同步锁阻塞
 class SynchronizedBlocked implements Runnable {
	 public synchronized void f() {
		 while(true) {
			 Thread.yield();
		 }
	 }
	 
	 //启动的时候，new 一个线程去抢占锁。
	 public SynchronizedBlocked() {
		 new Thread() {
			 public void run() {
				 f();
			 }
		 }.start();
	 }
	 @Override
	 public void run() {
		 System.out.println("Trying to call f()");
		 f();
		 System.out.println("Exiting SynchronizedBlocked.run()\n");
	 }
 }
 
 public class Interrupting {
	 private static ExecutorService exec = Executors.newCachedThreadPool();
	 
	 //送出中断
	 static void test(Runnable r) throws InterruptedException {
		 Future<?> f = exec.submit(r);
		 TimeUnit.MILLISECONDS.sleep(100);
		 System.out.println("Interrupting " + r.getClass().getName());
		 f.cancel(true);
		 System.out.println("Interrupt sent to " + r.getClass().getName());
	 }
	 
	 //分别对三中阻塞送出一记漂亮的中断
	 public static void main(String[] args) throws InterruptedException {
		 test(new SleepBlocked());
		 test(new IOBlocked(System.in));
		 test(new SynchronizedBlocked());
		 TimeUnit.SECONDS.sleep(3);
		 System.out.println("Abortin with System.exit(0)");
		 System.exit(0);
	 }
 }/*output:
 Interrupting concurrency.SleepBlocked
 Interrupt sent to concurrency.SleepBlocked
 InterruptedException!
 Exiting SleepBlocked.run()
 
 Waiting for read():
 Interrupting concurrency.IOBlocked
 Interrupt sent to concurrency.IOBlocked
 Trying to call f()
 Interrupting concurrency.SynchronizedBlocked
 Interrupt sent to concurrency.SynchronizedBlocked
 Abortin with System.exit(0)
 */

 package concurrency;
 
 import java.io.IOException;
 import java.net.InetSocketAddress;
 import java.net.ServerSocket;
 import java.nio.ByteBuffer;
 import java.nio.channels.AsynchronousCloseException;
 import java.nio.channels.ClosedByInterruptException;
 import java.nio.channels.SocketChannel;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
 
 class NIOBlocked implements Runnable {
  private final SocketChannel sc;
 
  public NIOBlocked(SocketChannel sc) {
	  this.sc = sc;
  }
 
  @Override
  public void run() {
	  try {
		  System.out.println("Waiting for read() in " + this);
		  sc.read(ByteBuffer.allocate(1));
	  } catch (ClosedByInterruptException e) {
		  System.out.println("ClosedByInterruptException");
	  } catch (AsynchronousCloseException e) {
		  System.out.println("AsynchronousCloseException");
	  } catch (IOException e) {
		  System.out.println("IOException");
	  }
	  System.out.println("Exiting NIOBloked.run() " + this);
  }
 }
 
 public class NIOinterruption {
  public static void main(String[] args) throws IOException, InterruptedException {
	  ExecutorService exec = Executors.newCachedThreadPool();
	  //启动一个 Server
	  ServerSocket server = new ServerSocket(8080);
	  InetSocketAddress isa = new InetSocketAddress("localhost", 8080);
	  SocketChannel sc1 = SocketChannel.open(isa);
	  SocketChannel sc2 = SocketChannel.open(isa);
	  Future<?> f = exec.submit(new NIOBlocked(sc1));
	  exec.execute(new NIOBlocked(sc2));
	  exec.shutdown();
	  TimeUnit.SECONDS.sleep(1);
	  f.cancel(true);
	  TimeUnit.SECONDS.sleep(1);
	  sc2.close();
  }
 }/*output:
 Waiting for read() in concurrency.NIOBlocked@352fd300
 Waiting for read() in concurrency.NIOBlocked@60fe2295
 ClosedByInterruptException
 Exiting NIOBloked.run() concurrency.NIOBlocked@352fd300
 AsynchronousCloseException
 Exiting NIOBloked.run() concurrency.NIOBlocked@60fe2295
 */

 package concurrency;
 
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
 
 class BlockedMutex {
  //使用的是重入锁，前面可是说过哦。可以尝试获取锁(时间也可设置)
  private Lock lock = new ReentrantLock();
  public BlockedMutex() {
	  lock.lock();
  }
  
  // 但是调用 lock.lockInterruptilby()就可以被中断，抛出 InterruptedException
  // 前面说过，凡是抛出 InterruptedException 的都可以从阻塞状态中断
  public void f() {
	  try {
		  lock.lockInterruptibly();
		  System.out.println("lock acquired in f()");
	  } catch(InterruptedException e) {
		  System.out.println("Interrupted from lock acquisition in f()");
	  }
  }
 }
 
 //首先new BlockedMutex()的时候就锁住了 blocked。而且永远不释放，那么 f()就会一直阻塞
 class Blocked2 implements Runnable {
  BlockedMutex blocked = new BlockedMutex();
  public void run() {
	  System.out.println("Waiting for f() in BlockedMutex()");
	  blocked.f();
	  System.out.println("Broken out of blocked call");
  }
 }
 
 public class Interrupting2 {
  public static void main(String[] args) throws InterruptedException {
	  Thread t = new Thread(new Blocked2());
	  t.start();
	  TimeUnit.SECONDS.sleep(1);
	  System.out.println("Issuing t.interrupt()");
	  t.interrupt();
  }
 }/*output:
 Waiting for f() in BlockedMutex()
 Issuing t.interrupt()
 Interrupted from lock acquisition in f()
 Broken out of blocked call
 */

 package concurrency;
 
 import java.util.concurrent.TimeUnit;
 
 class NeedsCleanup {
  private final int id;
 
  public NeedsCleanup(int ident) {
	  id = ident;
	  System.out.println("NeedsCleanup " + id);
  }
 
  public void cleanup() {
	  System.out.println("Cleaning up " + id);
  }
 }
 
 // 模拟一个计算密集型的任务
 class Blocked3 implements Runnable {
  private volatile double d = 0.0;
 
  public void run() {
	  try {
		  while (!Thread.interrupted()) {
			  // Point1 在需要清理的资源后，需要立即跟上 try-catch-finally
			  NeedsCleanup n1 = new NeedsCleanup(1);
			  try {
				  System.out.println("Sleeping");
				  TimeUnit.SECONDS.sleep(1);
 
				  // Point2 同上
				  NeedsCleanup n2 = new NeedsCleanup(2);
				  try {
					  System.out.println("Calculating");
					  for (int i = 1; i < 2500000; i++) {
						  d = d + (Math.PI + Math.E) / d;
					  }
					  System.out.println("Finished time-consuming operation");
				  } finally {
					  n2.cleanup();
				  }
			  } finally {
				  n1.cleanup();
			  }
		  }
		  System.out.println("Exiting via while() test");
	  } catch (InterruptedException e) {
		  System.out.println("Exiting via InterruptedException");
	  }
  }
 }
 
 // 通过传入不同的时间，来让 interrupt 发生在 Point1和 Point2的前后
 // 当在 P1和 P2之间传入中断，会在 while 循环结束后达到 while 条件退出
 // 当在 P1前面调用，会在视图调用阻塞(sleep()操作)或者在阻塞中(正在 sleep())通过 InterruptedException 退出阻塞
 // 那么，紧接着 n1和n2的 try-catch-finally 就会正确的清理资源
 public class IntererptingIdiom {
  public static void main(String[] args) throws NumberFormatException,
		  InterruptedException {
	  if (args.length != 1) {
		  System.out.println("Usage: java InterruptingIdiom delay-in-mS");
		  System.exit(1);
	  }
	  Thread t = new Thread(new Blocked3());
	  t.start();
	  TimeUnit.MILLISECONDS.sleep(new Integer(args[0]));
	  t.interrupt();
  }
 }