Thread基础

Java并发（基础知识）—— 创建、运行以及停止一个线程

      在计算机世界，当人们谈到并发时，它的意思是一系列的任务在计算机中同时执行。如果计算机有多个处理器或者多核处理器，那么这个同时性是真实发生的；如果计算机只有一个核心处理器那么就只是表面现象。

      现代所有的操作系统都允许并发地执行任务。你可以在听音乐和浏览网页新闻的同时阅读邮件，我们说这种并发是进程级别的并发。而且在同一进程内，也会同时有多种任务，这些在同一进程内运行的并发任务称之为线程。

      在这里我们要讨论的是线程级并发。Java提供了Thread类，使我们能够在一个Java进程中运行多个线程，每个线程执行不同的任务，以此实现并发。

1、创建线程                                                                                                 

    在Java中，我们有2个方式创建线程：

1. 通过直接继承thread类，然后覆盖run()方法。
2. 构建一个实现Runnable接口的类, 然后创建一个thread类对象并传递Runnable对象作为构造参数

    可以看到，这两种创建线程的方式都需要新建一个Thread对象，可以说一个Thread对象代表一个线程实例。

    由于Java是单继承的，如果我们使用第一种方式创建线程，就强制只能继承Thread，灵活性较低，对于第二种创建线程方式就没有这个问题，所以我们一般选择第二种方式创建线程。下面我们就使用第二种创建方式举一个简单的例子，首先，实现Runnable接口，输出1到10：

1 2 3 4 5 6 7 8

public class MyRunnable implements Runnable {      @Override      public void run() {          for ( int i =  0 ; i < 10 ; i++) {              System.out.println(i);          }      } }

    然后，建立main方法，新建线程并启动：　　

1 2 3 4 5 6 7

public class Main {      public static void main(String[] args) {          for ( int i = 0 ; i < 10 ; i++) {              new Thread( new MyRunnable()).start();          }      } }

　　可以看到使用这种方法创建线程，我们一共创建了两个类，一个类实现了Runnable接口，代表一个运行任务；一个类是运行类，在这个运行类的main方法中，我们利用刚刚定义的Runnable实例新建Thread并运行。利用这种方法创建线程，相较于第一种，代码逻辑十分清楚：一个类定义任务，一个类运行任务，所以推荐这种方式创建线程。 

2、运行线程                                                                                                

    运行一个线程的方法十分简单，我们只需调用Thread实例的start()方法即可，当我们调用start()方法之后，Java虚拟机会为我们创建一个线程，然后在该线程中运行run()方法中定义的任务，真正实现多线程。

    在这里，必须强调的是应该调用start()方法，而不是run()方法，直接调用run()方法，虚拟机不会新建线程运行任务，只会在当前线程执行任务，无法实现多线程并发，所以应该调用start()方法。

3、停止线程                                                                                                

    相较于创建与运行线程的简单，在Java中停止一个线程其实并不容易。Thread类虽然提供了stop()方法用于停止线程，但是该方法具有固有的不安全性。用 Thread.stop 来终止线程将释放它已经锁定的所有监视器。如果以前受这些监视器保护的任何对象处于一种不一致的状态，则损坏的对象将对其他线程可见，这有可能导致任意的行为，该方法已经被标注为过时的了，我们不应该使用该方法。

3.1、"已请求取消"标志

    既然如此，那么我们应该如何停止一个线程呢？我们可以使用"已请求取消"标志的方法停止线程。我们先在任务中定义该标志，然后任务会定期的查看该标志，如果设置了这个标志，那么任务将提前结束。以下程序使用该项技术来持续枚举素数，直到它被取消，注意，为保证这个过程能可靠地工作，标志必须设置为volatile类型：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

public class PrimeGenerator implements Runnable {      private final List<BigInteger> primes = new ArrayList<BigInteger>();      private volatile boolean cancelled;        public void run() {          BigInteger p = BigInteger.ONE;          while (!cancelled) {              p = p.nextProbablePrime();              synchronized ( this ) {                  primes.add(p);              }          }      }        public void cancel() {          cancelled = true ;      }        public synchronized List<BigInteger> get() {          return new ArrayList<BigInteger>(primes);      } }

　　在这里，PrimeGenerator类提供了cancel()方法，当这个方法被调用后，cancelled标志位就会被置为true，然后run()方法中的while循环就会结束，整个线程也就结束。 

3.2、使用中断停止线程

    使用"已请求取消"标志取消任务有一个问题，如果线程执行的是阻塞任务，那么线程将永远不会去检测取消标志，因此永远不会结束。

    当出现这种情况时，我们该如何结束线程呢？有部分阻塞库方法是支持中断的，线程中断是一种协作机制，线程可以通过这种机制来通知另一个线程，告诉它在合适的或者可能的情况下停止当前工作，并转而执行其他工作。

    我们可以修改上面的例子，不使用ArrayList存储素数结果，而使用BlockingQueue来存储，BlockingQueue的put()方法是可阻塞的，如果依然使用"已请求取消"标志的结束策略，同时put()方法被阻塞住后，那么该方法将永远不会停止，对于这种情况，我们可以使用检测中断标志位的方法来判断结束线程：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

public class PrimeProducer extends Thread {      private final BlockingQueue<BigInteger> queue;        PrimeProducer(BlockingQueue<BigInteger> queue) {          this .queue = queue;      }        public void run() {          try {              BigInteger p = BigInteger.ONE;              while (!Thread.currentThread().isInterrupted())                  queue.put(p = p.nextProbablePrime());          } catch (InterruptedException consumed) {              /* Allow thread to exit */          }      }        public void cancel() {          interrupt();      } }

　　这一次，cancle()方法不再设置结束标志位，而是调用interrupt()进行线程中断。当cancel()方法被调用之后，当前线程的中断标志位将被置为true，BlockingQueue的put()方法能够响应中断，并从阻塞状态返回，返回后，while语句检测到中断位被标志，然后结束while循环，整个线程结束。

3.3、不能响应中断的阻塞方法

    如果阻塞方法能够响应中断，那我们就可以使用以上的方法结束线程，但是Java类库中还有一些阻塞方法是不能够响应中断的，这些方法包括：

• java.io包中的同步Socket I/O
• java.io包中的同步I/O
• Selector的异步I/O
• 获取某个锁

    不过还好，对于I/O流，我们可以使用关闭底层I/O流的方式结束线程，以下代码给出了如何封装非标准的取消操作的例子，ReaderThread管理一个套接字连接，它采用同步方式从套接字中读取数据，为了结束某个用户的连接或者关闭服务器，ReaderThread改写了interrupt方法，使其既能处理标准中断，也能关闭底层套接字。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

public class ReaderThread extends Thread {      private static final int BUFSZ = 512 ;      private final Socket socket;      private final InputStream in;        public ReaderThread(Socket socket) throws IOException {          this .socket = socket;          this .in = socket.getInputStream();      }        public void interrupt() {          try {              socket.close();          } catch (IOException ignored) {          } finally {              super .interrupt();          }      }        public void run() {          try {              byte [] buf = new byte [BUFSZ];              while ( true ) {                  int count = in.read(buf);                  if (count < 0 )                      break ;                  else if (count > 0 )                      processBuffer(buf, count);              }          } catch (IOException e) { /* Allow thread to exit */          }      }        public void processBuffer( byte [] buf, int count) {      } }

　　对于这个具体的Thread类来说，我们调用interrupt()方法，线程首先会把socket关闭，然后再finally()中设置中断标志位。关闭socket之后，run()方法中的socket读取将立即抛异，catch子句将捕获该异常并顺利停止该线程。 

3.4、总结

    最后，让我对上面的内容总结一下：

    要结束一个线程，最理想方式是让其自动结束，如果你想提前结束线程的运行，那么需要区分三种情况。

    1、如果允许代码中不存在阻塞方法，你可以设置一个"结束"标志位，然后不停的检测它，当它为true时，主动结束线程；

    2、如果代码中存在阻塞方法，且该方法能够响应中断，那么你可以调用Thread.interput()结束线程；

    3、如果代码中存在阻塞方法，且该方法不能够响应中断，那么就需要通过关闭底层资源，让代码抛出异常的方式结束线程。