java Thread学习（终结任务）

Thread终结任务

TimeUnit类

java.util.concurrent.TimeUnit枚举类。用来代替Thread.sleep()方法。指定了休息时间的粒度

• DAYS:天
• HOURS：小时
• MINUTES：分钟
• SECONDS：秒
• MILLISECONDS：毫秒
• MICROSECONDS：微妙
• NANOSECONDS：纳秒

线程状态

• 新建：线程被创建的时候处于这种状态，分配资源+初始化。线程不会运行
• 就绪：经过start()启动后，进入就绪状态，这种状态下主要调度器分配时间就会运行。
• 阻塞：存在某个条件阻塞了线程的运行。
• 死亡：线程已经死亡(run()结束)，不可调度。但是任务的线程还是可以被中断。

进入阻塞状态的条件:

• sleep()进入休眠状态，等时间结束后继续运行。
• wait()导致线程挂起，等待线程得到notify()或notifyAll()消息（或者在java.util.concurrent类中等价的signal()或signalAll()消息），线程进入就绪
• 任务等待IO结束
• 任务试图调用同步控制的方法，但是对象锁不可用。

中断

1. Thread类中包含interrupt()方法，可以用来中断任务(将中断状态设为true)。需要持有Thread对象

   • 如果线程在调用wait/join/sleep等方法，会产生InterruptExceprion
   • 如果在IO阻塞或者获取对象锁阻塞，不会产生中断。

2. Executor：现在大多都不想直接操作Thread，使用Executor也可以产生中断

   • 使用shutdownNow()，可以直接中断所有任务
   • 不使用execute(Runnable),而是使用submit(Runnable),那么可以返回一个Future对象，可以通过这个对象进行中断，设置cancel(true)，那么会调用interrupt()

3. 对于IO的中断

   • 第一种可以直接关闭IO，那么任务将解除阻塞，产生InterruptedException
   • 使用NIO类中提供的方法，那么可以使用interrupt关闭，会产生ClosedByInterruptedException

   class NIOBlocked implements Runnable {
       private final SocketChannel sc;
       public NIOBlocked(SocketChannel sc) {
           this.sc = sc;
       }   
       public void run() {
           try{
               System.out.println("Waiting for read() in " + this);
               sc.read(ByteBuffer.allocate(1));
           } catch(ClosedByInterruptException e) {
               System.out.println("CloseByInterruptException");
           } catch(AsynchronousCloseException e) {
               System.out.println("AsynchronousCloseException");
           } catch(IOException e) {
               throw new RuntimeException(e);
           }
           System.out.println("Exiting NIOBlocked.run() " + this);
       }
   }
   public class NIOINterruption {
       public static void main(String[] args) throws Exception {
           ExecutorService service = Executors.newCachedThreadPool();
           ServerSocket server = new ServerSocket(8080);
           InetSocketAddress isa = new InetSocketAddress("localhost", 8080);
           SocketChannel sc1 = SocketChannel.open(isa);
           SocketChannel sc2 = SocketChannel.open(isa);
           Future<?> f = service.submit(new NIOBlocked(sc1));
           service.execute(new NIOBlocked(sc2));
           service.shutdownNow();
           TimeUnit.SECONDS.sleep(1);
           //f.cancel(true);   
           TimeUnit.SECONDS.sleep(1);
           //sc2.close();
       }
   }

4. 互斥阻塞

   • synchronized锁互斥阻塞的情况下中断，不能产生InterruptedException。在JavaSE5的时候，可以使用Lock进行加锁，在阻塞时中断，可以产生异常

   class BlockedMutex{
       private Lock lock = new ReentrantLock();
       public BlockedMutex(){
           lock.lock();
       }
       public void f() {
           try{
               lock.lockInterruptibly();
           } catch(InterruptedException e) {
               System.out.println("InterruptedException");
           }
       }
   }
   class Blocked2 implements Runnable {
       BlockedMutex blockedMutex = new BlockedMutex();
       public void run() {
           System.out.println("start");
           blockedMutex.f();
           System.out.println("end");
       }
   }
   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("t.interrupt()");
           t.interrupt();
       }
   }

5. 检查中断

   • 中断并不是直接结束一个任务的执行，而是设置一个中断状态，中断状态可能会产生InterrupedException也有可能是线程自身判断中断状态。（所以说设中断状态为true后，任务并不一定停止运行，而是会运行到一个检查点或者阻塞点）。
   • 使用Thread.interrupted()检查当前是否是中断转态，并且清楚中断状态，所以连续用两次Thread.interrupted()方法，第二次得到的是false

   - Thread.isInterrupted()只是检查中断状态

类	方法	应用
ExecutorService	awaitTermination(Long,TimeUnit)	指定时间内所有任务完成则返回true，否则false
Lock	lockInterruptibly()	锁可用，获取锁。如果在之前或者阻塞时中断，那么产生InterruptedException，并且清除中断。