系统学习java高并发系列二

转载请注明原创出处，谢谢！

什么是线程？

线程是进程的一个实体，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源(如程序计数器，一组寄存器和栈)，但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。

线程状态转换

1. 新建状态（New）：新创建了一个线程对象。
2. 就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。
3. 运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。
4. 阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。
   阻塞的情况分三种：

• 等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。
• 同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。
• 其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

5. 死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

Java线程：创建与启动

在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runable接口。

1. 扩展java.lang.Thread类。此类中有个run()方法，应该注意其用法：
   public void run()
   如果该线程是使用独立的Runnable运行对象构造的，则调用该Runnable对象的run方法；否则，该方法不执行任何操作并返回。Thread的子类应该重写该方法。
2. 实现java.lang.Runnable接口。
   public void run()
   使用实现接口Runnable的对象创建一个线程时，启动该线程将导致在独立执行的线程中调用对象的run方法。方法run的常规协定是，它可能执行任何所需的操作。

特别说明:线程创建的时候，优秀的编码建议，指定线程的名称，在dump线程的时候这样不会是Thread-1这种了，而是自己取的线程名称。

启动线程在线程的Thread对象上调用start()方法，而不是run()或者别的方法。

---

线程的优先级

每一个 Java 线程都有一个优先级，这样有助于操作系统确定线程的调度顺序。
Java 线程的优先级是一个整数，其取值范围是 1 （Thread.MIN_PRIORITY ） - 10 （Thread.MAX_PRIORITY ）。
默认情况下，每一个线程都会分配一个优先级 NORM_PRIORITY（5）。
具有较高优先级的线程对程序更重要，并且应该在低优先级的线程之前分配处理器资源。但是，线程优先级不能保证线程执行的顺序，而且非常依赖于平台。

java线程常用方法详解

1. sleep()

使当前线程（即调用该方法的线程）暂停执行一段时间，让其他线程有机会继续执行，但它并不释放对象锁。也就是说如果有synchronized同步快，其他线程仍然不能访问共享数据。注意该方法要捕捉异常。

例如有两个线程同时执行(没有synchronized)一个线程优先级为MAX_PRIORITY，另一个为MIN_PRIORITY，如果没有Sleep()方法，只有高优先级的线程执行完毕后，低优先级的线程才能够执行；但是高优先级的线程sleep(500)后，低优先级就有机会执行了。总之，sleep()可以使低优先级的线程得到执行的机会，当然也可以让同优先级、高优先级的线程有执行的机会。

2. join()

join()方法使调用该方法的线程在此之前执行完毕，也就是等待该方法的线程执行完毕后再往下继续执行。注意该方法也需要捕捉异常。

3. yield()

该方法与sleep()类似，只是不能由用户指定暂停多长时间，并且yield（）方法只能让同优先级的线程有执行的机会。

4. interrupt()

• 如果当前线程没有中断它自己（这在任何情况下都是允许的），则该线程的 checkAccess 方法就会被调用，这可能抛出 SecurityException。如果线程在调用 Object 类的 wait()、wait(long) 或 wait(long, int) 方法，或者该类的 join()、join(long)、join(long, int)、sleep(long) 或 sleep(long, int) 方法过程中受阻，则其中断状态将被清除，它还将收到一个 InterruptedException。
• 如果该线程在可中断的通道上的 I/O 操作中受阻，则该通道将被关闭，该线程的中断状态将被设置并且该线程将收到一个 ClosedByInterruptException。
• 如果该线程在一个 Selector 中受阻，则该线程的中断状态将被设置，它将立即从选择操作返回，并可能带有一个非零值，就好像调用了选择器的 wakeup 方法一样。
• 如果以前的条件都没有保存，则该线程的中断状态将被设置。中断一个不处于活动状态的线程不需要任何作用。

5. interrupted()

测试当前线程是否已经中断。线程的中断状态 由该方法清除。换句话说，如果连续两次调用该方法，则第二次调用将返回 false（在第一次调用已清除了其中断状态之后，且第二次调用检验完中断状态前，当前线程再次中断的情况除外）。线程中断被忽略，因为在中断时不处于活动状态的线程将由此返回 false 的方法反映出来。

一个线程在未正常结束之前, 被强制终止是很危险的事情. 因为它可能带来完全预料不到的严重后果. 所以你看到Thread.suspend, Thread.stop等方法都被Deprecated了。
那么不能直接把一个线程搞挂掉, 但有时候又有必要让一个线程死掉, 或者让它结束某种等待的状态 该怎么办呢? 优雅的方法就是, 给那个线程一个中断信号, 让它自己决定该怎么办. 比如说, 在某个子线程中为了等待一些特定条件的到来, 你调用了Thread.sleep(10000), 预期线程睡10秒之后自己醒来, 但是如果这个特定条件提前到来的话, 你怎么通知一个在睡觉的线程呢? 又比如说, 主线程通过调用子线程的join方法阻塞自己以等待子线程结束, 但是子线程运行过程中发现自己没办法在短时间内结束, 于是它需要想办法告诉主线程别等我了. 这些情况下, 就需要中断.中断是通过调用Thread.interrupt()方法来做的. 这个方法通过修改了被调用线程的中断状态来告知那个线程, 说它被中断了. 对于非阻塞中的线程, 只是改变了中断状态, 即Thread.isInterrupted()将返回true; 对于可取消的阻塞状态中的线程, 比如等待在这些函数上的线程, Thread.sleep(), Object.wait(), Thread.join(), 这个线程收到中断信号后, 会抛出InterruptedException, 同时会把中断状态置回为false.

//Interrupted的经典使用代码      
   public void run(){      
           try{      
                ....      
                while(!Thread.currentThread().isInterrupted()&& more work to do){      
                       // do more work;      
                }      
           }catch(InterruptedException e){      
                       // thread was interrupted during sleep or wait      
           }      
           finally{      
                      // cleanup, if required      
           }      
   }      

很显然，在上面代码中，while循环有一个决定因素就是需要不停的检查自己的中断状态。当外部线程调用该线程的interrupt 时，使得中断状态置位即变为true。这是该线程将终止循环，不在执行循环中的do more work了。这说明: interrupt中断的是线程的某一部分业务逻辑，前提是线程需要检查自己的中断状态(isInterrupted())。但是当线程被阻塞的时候，比如被Object.wait, Thread.join和Thread.sleep三种方法之一阻塞时。调用它的interrput()方法。可想而知，没有占用CPU运行的线程是不可能给自己的中断状态置位的。这就会产生一个InterruptedException异常。

/*   
   * 如果线程被阻塞，它便不能核查共享变量，也就不能停止。这在许多情况下会发生，例如调用  
   * Object.wait()、ServerSocket.accept()和DatagramSocket.receive()时，他们都可能永  
   * 久的阻塞线程。即使发生超时，在超时期满之前持续等待也是不可行和不适当的，所以，要使  
   * 用某种机制使得线程更早地退出被阻塞的状态。很不幸运，不存在这样一种机制对所有的情况  
   * 都适用，但是，根据情况不同却可以使用特定的技术。使用Thread.interrupt()中断线程正  
   * 如Example1中所描述的，Thread.interrupt()方法不会中断一个正在运行的线程。这一方法  
   * 实际上完成的是，在线程受到阻塞时抛出一个中断信号，这样线程就得以退出阻塞的状态。更  
   * 确切的说，如果线程被Object.wait, Thread.join和Thread.sleep三种方法之一阻塞，那么，  
   * 它将接收到一个中断异常（InterruptedException），从而提早地终结被阻塞状态。因此，  
   * 如果线程被上述几种方法阻塞，正确的停止线程方式是设置共享变量，并调用interrupt()（注  
   * 意变量应该先设置）。如果线程没有被阻塞，这时调用interrupt()将不起作用；否则，线程就  
   * 将得到异常（该线程必须事先预备好处理此状况），接着逃离阻塞状态。在任何一种情况中，最  
   * 后线程都将检查共享变量然后再停止。下面示例描述了该技术。  
   * */    
   package Concurrency.Interrupt;    
  
   class Example3 extends Thread {    
  
   volatile boolean stop = false;    
  
   public static void main(String args[]) throws Exception {    
   Example3 thread = new Example3();    
  
   System.out.println("Starting thread...");    
   thread.start();    
  
   Thread.sleep(3000);    
  
   System.out.println("Asking thread to stop...");    
  
   /*  
   * 如果线程阻塞，将不会检查此变量,调用interrupt之后，线程就可以尽早的终结被阻   
   * 塞状 态，能够检查这一变量。  
   * */    
   thread.stop = true;    
  
   /*  
   * 这一方法实际上完成的是，在线程受到阻塞时抛出一个中断信号，这样线程就得以退  
   * 出阻 塞的状态  
   * */    
   thread.interrupt();    
  
   Thread.sleep(3000);    
   System.out.println("Stopping application...");    
   System.exit(0);    
   }    
  
   public void run() {    
   while (!stop) {    
   System.out.println("Thread running...");    
   try {    
   Thread.sleep(2000);    
   } catch (InterruptedException e) {    
   // 接收到一个中断异常（InterruptedException），从而提早地终结被阻塞状态    
   System.out.println("Thread interrupted...");    
   }    
   }    
  
   System.out.println("Thread exiting under request...");    
   }    
   }    
   /*  
   * 把握几个重点：stop变量、run方法中的sleep()、interrupt()、InterruptedException。串接起  
   * 来就是这个意思：当我们在run方法中调用sleep（或其他阻塞线程的方法）时，如果线程阻塞的  
   * 时间过长，比如10s，那在这10s内，线程阻塞，run方法不被执行，但是如果在这10s内，stop被  
   * 设置成true，表明要终止这个线程，但是，现在线程是阻塞的，它的run方法不能执行，自然也就  
   * 不能检查stop，所 以线程不能终止，这个时候，我们就可以用interrupt()方法了：我们在  
   * thread.stop = true;语句后调用thread.interrupt()方法， 该方法将在线程阻塞时抛出一个中断  
   * 信号，该信号将被catch语句捕获到，一旦捕获到这个信号，线程就提前终结自己的阻塞状态，这  
   * 样，它就能够 再次运行run 方法了，然后检查到stop = true，while循环就不会再被执行，在执  
   * 行了while后面的清理工作之后，run方法执行完 毕，线程终止。  
   * */    

当代码调用中须要抛出一个InterruptedException, 你可以选择把中断状态复位, 也可以选择向外抛出InterruptedException, 由外层的调用者来决定。
不是所有的阻塞方法收到中断后都可以取消阻塞状态, 输入和输出流类会阻塞等待 I/O 完成，但是它们不抛出 InterruptedException，而且在被中断的情况下也不会退出阻塞状态。
尝试获取一个内部锁的操作（进入一个 synchronized 块）是不能被中断的。

有关线程的同步操作，在后续章节会详细讲解到。

---

个人公众号