BlogJava-Jiangshachina-随笔分类-Java并发基础实践

Java并发基础实践--死锁(原)

Sha Jiang — Sun, 29 Dec 2013 12:19:00 GMT

Java并发基础实践--死锁

本文是Java并发基础实践系列中的一篇，介绍了最简单的死锁场景，并使用jstack产生的thread dump来查找死锁。(2013.12.29最后更新)

1. 死锁
为了能够维护线程的安全性，Java提供的锁机制，但不恰当地使用锁则可能产生死锁。死锁是并发编程中一个无法绕开的问题。只要在一个任务中使用了一个以上的锁，那么就存在死锁的风险。
死锁产生的直接原因非常简单，即两个线程在相互等待对方所执有的锁。

2. 锁顺序死锁
在死锁场景中，最典型的就是锁顺序死锁，代码清单1就是一个很常见的示例。

清单1
public class DeadLock {

    private Object leftLock = new Object();
    private Object rightLock = new Object();

    public void leftRight() {
        synchronized (leftLock) {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            synchronized (rightLock) {
                System.out.println("leftRight");
            }
        }
    }

    public void rightLeft() {
        synchronized (rightLock) {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            synchronized (leftLock) {
                System.out.println("leftRight");
            }
        }
    }

    public static void main(String[] args) {
        final DeadLock deadLock = new DeadLock();

        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                deadLock.leftRight();
            }
        });

        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                deadLock.rightLeft();
            }
        });

        t1.start();
        t2.start();
    }
}

3. Thread Dump
JDK提供了一组命令行工具，其中就包括jstack。通过jstack可以获取当前正运行的Java进程的java stack和native stack信息。如果Java进程崩溃了，也可以通过它来获取core file中的java stack和native stack信息，以方便我们定位问题。
为了能够使用jstack去输出目标Java进程的thread dump，首先必须要弄清楚在执行清单1的程序时，该程序的进程号。JDK提供的另一个命令行工具jps可以获取系统中所有Java进程的相关信息。
在命令行窗口中执行命令jps，即可以得到清单2所示的结果

清单2
C:\Documents and Settings\Administrator>jps
2848
4552 DeadLock
5256 Jps

其中4552就是在笔者机器上执行程序DeadLock时所生成Java进程的进程号。
然后再执行命令jstack 4552，在笔者的机器上就会得到清单3所示的结果

清单3
C:\Documents and Settings\Administrator>jstack 4552
2013-12-29 18:45:41
Full thread dump Java HotSpot(TM) Client VM (23.25-b01 mixed mode, sharing):

"DestroyJavaVM" prio=6 tid=0x00878800 nid=0xd00 waiting on condition [0x00000000]
   java.lang.Thread.State: RUNNABLE

"Thread-1" prio=6 tid=0x02b56c00 nid=0x14ec waiting for monitor entry [0x02fdf000]
   java.lang.Thread.State: BLOCKED (on object monitor)
        at concurrency.deadlock.DeadLock.rightLeft(DeadLock.java:33)
        - waiting to lock <0x22be6598> (a java.lang.Object)
        - locked <0x22be65a0> (a java.lang.Object)
        at concurrency.deadlock.DeadLock$2.run(DeadLock.java:53)
        at java.lang.Thread.run(Thread.java:724)

"Thread-0" prio=6 tid=0x02b55c00 nid=0x354 waiting for monitor entry [0x02f8f000]
   java.lang.Thread.State: BLOCKED (on object monitor)
        at concurrency.deadlock.DeadLock.leftRight(DeadLock.java:19)
        - waiting to lock <0x22be65a0> (a java.lang.Object)
        - locked <0x22be6598> (a java.lang.Object)
        at concurrency.deadlock.DeadLock$1.run(DeadLock.java:45)
        at java.lang.Thread.run(Thread.java:724)

"Service Thread" daemon prio=6 tid=0x02b34800 nid=0x133c runnable [0x00000000]
   java.lang.Thread.State: RUNNABLE

"C1 CompilerThread0" daemon prio=10 tid=0x02b13800 nid=0x10fc waiting on condition [0x00000000]
   java.lang.Thread.State: RUNNABLE

"Attach Listener" daemon prio=10 tid=0x02b11c00 nid=0x1424 waiting on condition [0x00000000]
   java.lang.Thread.State: RUNNABLE

"Signal Dispatcher" daemon prio=10 tid=0x02b10800 nid=0x1100 runnable [0x00000000]
   java.lang.Thread.State: RUNNABLE

"Finalizer" daemon prio=8 tid=0x02af4c00 nid=0x1238 in Object.wait() [0x02daf000]
   java.lang.Thread.State: WAITING (on object monitor)
        at java.lang.Object.wait(Native Method)
        - waiting on <0x22b60fb8> (a java.lang.ref.ReferenceQueue$Lock)
        at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:135)
        - locked <0x22b60fb8> (a java.lang.ref.ReferenceQueue$Lock)
        at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:151)
        at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:189)

"Reference Handler" daemon prio=10 tid=0x02af0000 nid=0x12e8 in Object.wait() [0x02d5f000]
   java.lang.Thread.State: WAITING (on object monitor)
        at java.lang.Object.wait(Native Method)
        - waiting on <0x22b60da0> (a java.lang.ref.Reference$Lock)
        at java.lang.Object.wait(Object.java:503)
        at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:133)
        - locked <0x22b60da0> (a java.lang.ref.Reference$Lock)

"VM Thread" prio=10 tid=0x02aee400 nid=0x129c runnable

"VM Periodic Task Thread" prio=10 tid=0x02b48000 nid=0x89c waiting on condition

JNI global references: 117

Found one Java-level deadlock:
=============================
"Thread-1":
  waiting to lock monitor 0x02af4a3c (object 0x22be6598, a java.lang.Object),
  which is held by "Thread-0"
"Thread-0":
  waiting to lock monitor 0x02af310c (object 0x22be65a0, a java.lang.Object),
  which is held by "Thread-1"

Java stack information for the threads listed above:
===================================================
"Thread-1":
        at concurrency.deadlock.DeadLock.rightLeft(DeadLock.java:33)
        - waiting to lock <0x22be6598> (a java.lang.Object)
        - locked <0x22be65a0> (a java.lang.Object)
        at concurrency.deadlock.DeadLock$2.run(DeadLock.java:53)
        at java.lang.Thread.run(Thread.java:724)
"Thread-0":
        at concurrency.deadlock.DeadLock.leftRight(DeadLock.java:19)
        - waiting to lock <0x22be65a0> (a java.lang.Object)
        - locked <0x22be6598> (a java.lang.Object)
        at concurrency.deadlock.DeadLock$1.run(DeadLock.java:45)
        at java.lang.Thread.run(Thread.java:724)

Found 1 deadlock.

在上述输出中，我们可以很明确地看到一个死锁

"Thread-1":
  waiting to lock monitor 0x02af4a3c (object 0x22be6598, a java.lang.Object),
  which is held by "Thread-0"
"Thread-0":
  waiting to lock monitor 0x02af310c (object 0x22be65a0, a java.lang.Object),
  which is held by "Thread-1"

并且它还标明了程序是在哪个地方时发现了上述死锁

"Thread-1":
        at concurrency.deadlock.DeadLock.rightLeft(DeadLock.java:33)
        - waiting to lock <0x22be6598> (a java.lang.Object)
        - locked <0x22be65a0> (a java.lang.Object)
        at concurrency.deadlock.DeadLock$2.run(DeadLock.java:53)
        at java.lang.Thread.run(Thread.java:724)
"Thread-0":
        at concurrency.deadlock.DeadLock.leftRight(DeadLock.java:19)
        - waiting to lock <0x22be65a0> (a java.lang.Object)
        - locked <0x22be6598> (a java.lang.Object)
        at concurrency.deadlock.DeadLock$1.run(DeadLock.java:45)
        at java.lang.Thread.run(Thread.java:724)

4. 小结
死锁产生的直接原因非常简单，即两个线程在相互等待对方所执有的锁。锁顺序死锁是其中最经典的场景，此外还有动态的锁顺序死锁。虽然表现形式有所不同，但本质上都是两个线程在以不同的顺序来获取相同锁时，发生了死锁问题。
使用thread dump可以帮助我们分析死锁产生的原因。除了直接使用jstack命令来获取thread dump输出以外，JDK还提供了jvisualvm工具，它能以可视化的方式展示Java程序的进程号并导出thread dump。

Sha Jiang 2013-12-29 20:19 发表评论

Java并发基础实践--分而治之(原)

Sha Jiang — Wed, 23 Oct 2013 15:27:00 GMT

摘要: Java并发基础实践--分而治之本系列的第三篇文章将以实现一个极简单的查找最大数的任务为例，分别给出了四个版本：1.顺序执行；2.基于传统的Thread.join()；3.基于并发工具包的Future；4.基于JDK 7引入的Fork/Join框架。(2013.10.25最后更新) 分而治之(Divide-and-Conquer)是解决复杂问题的常用方法。在并发... 阅读全文

Sha Jiang 2013-10-23 23:27 发表评论

Java并发基础实践--退出任务II(原)

Sha Jiang — Mon, 07 Oct 2013 08:55:00 GMT

Java并发基础实践--退出任务II

在本系列的上一篇中所述的退出并发任务的方式都是基于JDK 5之前的API，本文将介绍使用由JDK 5引入的并发工具包中的API来退出任务。(2013.10.08最后更新)

在本系列的前一篇中讲述了三种退出并发任务的方式--停止线程；可取消的任务；中断，但都是基于JDK 5之前的API。本篇将介绍由JDK 5引入的java.concurrent包中的Future来取消任务的执行。

1. Future模式
Future是并发编程中的一种常见设计模式，它相当于是Proxy模式与Thread-Per-Message模式的结合。即，每次都创建一个单独的线程去执行一个耗时的任务，并且创建一个Future对象去持有实际的任务对象，在将来需要的时候再去获取实际任务的执行结果。
依然先创建一个用于扫描文件的任务FileScannerTask，如代码清单1所示，

清单1
public class FileScannerTask implements Runnable {

    private File root = null;

    private ArrayList<String> filePaths = new ArrayList<String>();

    public FileScannerTask(File root) {
        if (root == null || !root.exists() || !root.isDirectory()) {
            throw new IllegalArgumentException("root must be directory");
        }

        this.root = root;
    }

    @Override
    public void run() {
        travleFiles(root);
    }

    private void travleFiles(File parent) {
        String filePath = parent.getAbsolutePath();
        filePaths.add(filePath);

        if (parent.isDirectory()) {
            File[] children = parent.listFiles();
            if (children != null) {
                for (File child : children) {
                    travleFiles(child);
                }
            }
        }
    }

    public List<String> getFilePaths() {
        return (List<String>) filePaths.clone();
    }
}

此处的文件扫描任务，提供了一个getFilePaths()方法以允许随时都可以取出当前已扫描过的文件的路径(相当于一个任务快照)。然后，创建一个针对该任务的Future类，如代码清单2所示，

清单2
public class FileScannerFuture {

    private FileScannerTask task = null;

    public FileScannerFuture(FileScannerTask task) {
        new Thread(task).start();
        this.task = task;
    }

    public List<String> getResult() {
        return task.getFilePaths();
    }
}

FileScannerFuture持有FileScannerTask的引用，并创建一个独立的线程来执行该任务。在任务的执行过程中，应用程序可以在"未来"的某个时刻去获取一个任务的快照，如代码清单3所示，

清单3
public static void main(String[] args) throws Exception {
    FileScannerFuture future = new FileScannerFuture(new FileScannerTask(new File("C:")));

    TimeUnit.SECONDS.sleep(1);
    List<String> filePaths1 = future.getResult();
    System.out.println(filePaths1.size());

    TimeUnit.SECONDS.sleep(1);
    List<String> filePaths2 = future.getResult();
    System.out.println(filePaths2.size());
}

2. 使用并发工具包中的Future实现
前面所展示的Future实现十分的简陋，没有实际应用的意义。使用FileScannerFuture，应用程序在获取filePaths时，无法得知其获取的是否为最终结果，即无法判断FileScannerTask是否已经完成。而且，也不能在必要时停止FileScannerTask的执行。毫无疑问，由JDK 5引入的并发工具包肯定会提供此类实用工具，如FutureTask。为了使用并发工具包中的Future，需要修改前述的FileScannerTask实现，让其实现Callable接口，如代码清单4所示，

清单4
public class FileScannerTask implements Callable<List<String>> {

    private File root = null;

    private List<String> filePaths = new ArrayList<String>();

    public FileScannerTask(File root) {
        if (root == null || !root.exists() || !root.isDirectory()) {
            throw new IllegalArgumentException("root must be directory");
        }

        this.root = root;
    }

    @Override
    public List<String> call() {
        travleFiles(root);
        return filePaths;
    }

    private void travleFiles(File parent) {
        String filePath = parent.getAbsolutePath();
        filePaths.add(filePath);

        if (parent.isDirectory()) {
            File[] children = parent.listFiles();
            if (children != null) {
                for (File child : children) {
                    travleFiles(child);
                }
            }
        }
    }

    public List<String> getFilePaths() {
        return (List<String>) filePaths.clone();
    }
}

应用程序也要相应的修改成如代码清单5所示，使用ExecutorService来提交任务，并创建一个Future/FutureTask实例。

清单5
public static void main(String[] args) {
    ExecutorService executorService = Executors.newCachedThreadPool();
    Future<List<String>> future = executorService.submit(new FileScannerTask(new File("C:")));

    try {
        List<String> filePaths = future.get();
        System.out.println(filePaths.size());
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    }

    executorService.shutdown();
}

此处就是调用Future.get()方法来获取任务的执行结果，如果任务没有执行完毕，那么该方法将会被阻塞。该Future实现的好处就是，正常情况下，只有在任务执行完毕之后才能获取其结果，以保证该结果是最终执行结果。

3. 使用Future取消任务
Future除了定义有可获取执行结果的get方法(get()以及get(long timeout, TimeUnit unit))，还定义了三个方法：cancel()，isCancelled()以及isDone()，用于取消任务，以及判定任务是否已被取消、已执行完毕。如代码清单6所示，

清单6
public interface Future<V> {

    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();

}

其中，cancel()方法中的boolean参数若为true，表示在取消该任务时，若执行该任务的线程仍在运行中，则对其进行中断。如代码清单7所示，若任务执行超时了，那么就取消它。

清单7
public static void main(String[] args) {
    ExecutorService executorService = Executors.newCachedThreadPool();
    Future<List<String>> future = executorService.submit(new FileScannerTask(new File("C:")));

    try {
        List<String> filePaths = future.get(1, TimeUnit.SECONDS);
        System.out.println(filePaths.size());
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    } catch (TimeoutException e) {
        e.printStackTrace();
    } finally {
        future.cancel(true);
    }

    executorService.shutdown();
}

在实际应用中，取消任务的原由肯定不仅仅只是超时这么简单，还可能是由于接受到了用户的指令。此时，则可能会从另一个独立线程去取消该任务。除了取消任务之外，有时还需要取出任务中已经生成的部分结果。但为了能够响应任务的退出，首先需要修改FileScannerTask，使得当任务被取消(中断)时，任务能够真正的快速停止并返回，如代码清单8所示，

清单8
public class FileScannerTask implements Callable<List<String>> {



    private void travleFiles(File parent) {
        if (Thread.currentThread().isInterrupted()) {
            return;
        }

        String filePath = parent.getAbsolutePath();
        filePaths.add(filePath);

        if (parent.isDirectory()) {
            File[] children = parent.listFiles();
            if (children != null) {
                for (File child : children) {
                    travleFiles(child);
                }
            }
        }
    }


}

相应地修改应用程序的代码，如代码清单9所示，

清单9
public static void main(String[] args) {
    ExecutorService executorService = Executors.newCachedThreadPool();
    FileScannerTask task = new FileScannerTask(new File("C:"));
    final Future<List<String>> future = executorService.submit(task);

    new Thread(new Runnable() {

        @Override
        public void run() {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            future.cancel(true);
        }
    }).start();

    try {
        List<String> filePaths = future.get();
        System.out.println(filePaths.size());
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    } catch (CancellationException e) {
        List<String> filePaths = task.getFilePaths();
        System.out.println("Partly result: " + filePaths.size());
    }

    executorService.shutdown();
}

由上可知，此处使用Future.cancel(true)的本质依然是利用了线程的中断机制。

4. 小结
使用Future可以在任务启动之后的特定时机再去获取任务的执行结果。由JDK 5引入的并发工具包中提供的Future实现不仅可以获取任务的执行结果，还可以用于取消任务的执行。

Sha Jiang 2013-10-07 16:55 发表评论

Java并发基础实践--退出任务I(原)

Sha Jiang — Sat, 21 Sep 2013 11:11:00 GMT

Java并发基础实践--退出任务I

计划写一个"Java并发基础实践"系列，算作本人对Java并发学习与实践的简单总结。本文是该系列的第一篇，介绍了退出并发任务的最简单方法。(2013.09.25最后更新)

在一个并发任务被启动之后，不要期望它总是会执行完成。由于时间限制，资源限制，用户操作，甚至是任务中的异常(尤其是运行时异常)，...都可能造成任务不能执行完成。如何恰当地退出任务是一个很常见的问题，而且实现方法也不一而足。

1. 任务
创建一个并发任务，递归地获取指定目录下的所有子目录与文件的绝对路径，最后再将这些路径信息保存到一个文件中，如代码清单1所示：

清单1
public class FileScanner implements Runnable {

    private File root = null;

    private List<String> filePaths = new ArrayList<String>();

    public FileScanner1(File root) {
        if (root == null || !root.exists() || !root.isDirectory()) {
            throw new IllegalArgumentException("root must be legal directory");
        }

        this.root = root;
    }

    @Override
    public void run() {
        travleFiles(root);
        try {
            saveFilePaths();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void travleFiles(File parent) {
        String filePath = parent.getAbsolutePath();
        filePaths.add(filePath);

        if (parent.isDirectory()) {
            File[] children = parent.listFiles();
            for (File child : children) {
                travleFiles(child);
            }
        }
    }

    private void saveFilePaths() throws IOException {
        FileWriter fos = new FileWriter(new File(root.getAbsoluteFile()
                + File.separator + "filePaths.out"));
        for (String filePath : filePaths) {
            fos.write(filePath + "\n");
        }
        fos.close();
    }
}

2. 停止线程
有一个很直接，也很干脆的方式来停止线程，就是调用Thread.stop()方法，如代码清单2所示：

清单2
public static void main(String[] args) throws Exception {
    FileScanner task = new FileScanner(new File("C:"));
    Thread taskThread = new Thread(task);
    taskThread.start();

    TimeUnit.SECONDS.sleep(1);
    taskThread.stop();
}

但是，地球人都知道Thread.stop()在很久很久之前就不推荐使用了。根据官方文档的介绍，该方法存在着固有的不安全性。当停止线程时，将会释放该线程所占有的全部监视锁，这就会造成受这些锁保护的对象的不一致性。在执行清单2的应用程序时，它的运行结果是不确定的。它可能会输出一个文件，其中包含部分的被扫描过的目录和文件。但它也很有可能什么也不输出，因为在执行FileWriter.write()的过程中，可能由于线程停止而造成了I/O异常，使得最终无法得到输出文件。

3. 可取消的任务
另外一种十分常见的途径是，在设计之初，我们就使任务是可被取消的。一般地，就是提供一个取消标志或设定一个取消条件，一旦任务遇到该标志或满足了取消条件，就会结束任务的执行。如代码清单3所示：

清单3
public class FileScanner implements Runnable {

    private File root = null;

    private List<String> filePaths = new ArrayList<String>();

    private boolean cancel = false;

    public FileScanner(File root) {

    }

    @Override
    public void run() {

    }

    private void travleFiles(File parent) {
        if (cancel) {
            return;
        }

        String filePath = parent.getAbsolutePath();
        filePaths.add(filePath);

        if (parent.isDirectory()) {
            File[] children = parent.listFiles();
            for (File child : children) {
                travleFiles(child);
            }
        }
    }

    private void saveFilePaths() throws IOException {

    }

    public void cancel() {
        cancel = true;
    }
}

新的FileScanner实现提供一个cancel标志，travleFiles()会遍历新的文件之前检测该标志，若该标志为true，则会立即返回。代码清单4是使用新任务的应用程序。

清单4
public static void main(String[] args) throws Exception {
    FileScanner task = new FileScanner(new File("C:"));
    Thread taskThread = new Thread(task);
    taskThread.start();

    TimeUnit.SECONDS.sleep(3);
    task.cancel();
}

但有些时候使用可取消的任务，并不能快速地退出任务。因为任务在检测取消标志之前，可能正处于等待状态，甚至可能被阻塞着。对清单2中的FileScanner稍作修改，让每次访问新的文件之前先睡眠10秒钟，如代码清单5所示：

清单5
public class FileScanner implements Runnable {



    private void travleFiles(File parent) {
        try {
            TimeUnit.SECONDS.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        if (cancel) {
            return;
        }


    }

    private void saveFilePaths() throws IOException {

    }

    public void cancel() {
        cancel = true;
    }
}

再执行清单3中的应用程序时，可能发现任务并没有很快速的退出，而是又等待了大约7秒钟才退出。如果在检查cancel标志之前要先获取某个受锁保护的资源，那么该任务就会被阻塞，并且无法确定何时能够退出。对于这种情况，就需要使用中断了。

4. 中断
中断是一种协作机制，它并不会真正地停止一个线程，而只是提醒线程需要被中断，并将线程的中断状态设置为true。如果线程正在执行一些可抛出InterruptedException的方法，如Thread.sleep()，Thread.join()和Object.wait()，那么当线程被中断时，上述方法就会抛出InterruptedException，并且中断状态会被重新设置为false。任务程序只要恰当处理该异常，就可以正常地退出任务。对清单5再稍作修改，即，如果任务在睡眠时遇上了InterruptedException，那么就取消任务。如代码清单6所示：

清单6
public class FileScanner implements Runnable {



    private void travleFiles(File parent) {
        try {
            TimeUnit.SECONDS.sleep(10);
        } catch (InterruptedException e) {
            cancel();
        }

        if (cancel) {
            return;
        }


    }


}

同时将清单4中的应用程序，此时将调用Thread.interrupt()方法去中断线程，如代码清单7所示：

清单7
public static void main(String[] args) throws Exception {
    FileScanner3 task = new FileScanner3(new File("C:"));
    Thread taskThread = new Thread(task);
    taskThread.start();

    TimeUnit.SECONDS.sleep(3);
    taskThread.interrupt();
}

或者更进一步，仅使用中断状态来控制程序的退出，而不再使用可取消的任务(即，删除cancel标志)，将清单6中的FileScanner修改成如下：

清单8
public class FileScanner implements Runnable {



    private void travleFiles(File parent) {
        try {
            TimeUnit.SECONDS.sleep(10);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        if (Thread.currentThread().isInterrupted()) {
            return;
        }


    }


}

再次执行清单7的应用程序后，新的FileScanner也能即时的退出了。值得注意的是，因为当sleep()方法抛出InterruptedException时，该线程的中断状态将又会被设置为false，所以必须要再次调用interrupt()方法来保存中断状态，这样在后面才可以利用中断状态来判定是否需要返回travleFiles()方法。当然，对于此处的例子，在收到InterruptedException时也可以选择直接返回，如代码清单9所示：

清单9
public class FileScanner implements Runnable {



    private void travleFiles(File parent) {
        try {
            TimeUnit.SECONDS.sleep(10);
        } catch (InterruptedException e) {
            return;
        }


    }


}

5 小结
本文介绍了三种简单的退出并发任务的方法：停止线程；使用可取消任务；使用中断。毫无疑问，停止线程是不可取的。使用可取消的任务时，要避免任务由于被阻塞而无法及时，甚至永远无法被取消。一般地，恰当地使用中断是取消任务的首选方式。

Sha Jiang 2013-09-21 19:11 发表评论