jdk1.5中java.util.concurrent包编写多线程（三）

62 阅读 0 评论 41 点赞

我是靠谱客的博主称心黄豆，最近开发中收集的这篇文章主要介绍jdk1.5中java.util.concurrent包编写多线程（三），觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

有时候在实际应用中，某些操作很耗时，但又不是不可或缺的步骤。比如用网页浏览器浏览新闻时，最重要的是要显示文字内容，至于与新闻相匹配的图片就没有那么重要的，所以此时首先保证文字信息先显示，而图片信息会后显示，但又不能不显示，由于下载图片是一个耗时的操作，所以必须一开始就得下载。

Java的并发库的Future类就可以满足这个要求。Future的重要方法包括get()和cancel()，get()获取数据对象，如果数据没有加载，就会阻塞直到取到数据，而 cancel()是取消数据加载。另外一个get(timeout)操作，表示如果在timeout时间内没有取到就失败返回，而不再阻塞。

下面的Demo简单的说明了Future的使用方法：一个非常耗时的操作必须一开始启动，但又不能一直等待；其他重要的事情又必须做，等完成后，就可以做不重要的事情。

package concurrent;

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

public class TestFutureTask {

public static void main(String[] args)throws InterruptedException,

      ExecutionException {

    final ExecutorService exec = Executors.newFixedThreadPool(5);

    Callable<String> call = new Callable<String>() {

      public String call() throws Exception {

        Thread.sleep(1000 * 5);

        return "Other less important but longtime things.";

      }

    };

    Future<String> task = exec.submit(call);

    // 重要的事情

    Thread.sleep(1000 * 3);

    System.out.println("Let's do important things.");

    // 其他不重要的事情

    String obj = task.get();

    System.out.println(obj);

    // 关闭线程池

    exec.shutdown();

}

} 

运行结果：

Let's do important things.

Other less important but longtime things.

考虑以下场景：浏览网页时，浏览器了5个线程下载网页中的图片文件，由于图片大小、网站访问速度等诸多因素的影响，完成图片下载的时间就会有很大的不同。如果先下载完成的图片就会被先显示到界面上，反之，后下载的图片就后显示。

Java的并发库的CompletionService可以满足这种场景要求。该接口有两个重要方法：submit()和take()。submit用于提交一个runnable或者callable，一般会提交给一个线程池处理；而take就是取出已经执行完毕runnable或者callable实例的Future对象，如果没有满足要求的，就等待了。 CompletionService还有一个对应的方法poll，该方法与take类似，只是不会等待，如果没有满足要求，就返回null对象。

package concurrent;

import java.util.concurrent.Callable;

import java.util.concurrent.CompletionService;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorCompletionService;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

public class TestCompletionService {

public static void main(String[] args) throws InterruptedException,

      ExecutionException {

    ExecutorService exec = Executors.newFixedThreadPool(10);

CompletionService<String> serv = 

new ExecutorCompletionService<String>(exec);

    for (int index = 0; index < 5; index++) {

      final int NO = index;

      Callable<String> downImg = new Callable<String>() {

        public String call() throws Exception {

          Thread.sleep((long) (Math.random() * 10000));

          return "Downloaded Image " + NO;

        }

      };

      serv.submit(downImg);

    }

    Thread.sleep(1000 * 2);

    System.out.println("Show web content");

    for (int index = 0; index < 5; index++) {

      Future<String> task = serv.take();

      String img = task.get();

      System.out.println(img);

    }

    System.out.println("End");

    // 关闭线程池

    exec.shutdown();

}

} 

运行结果:

Show web content

Downloaded Image 1

Downloaded Image 2

Downloaded Image 4

Downloaded Image 0

Downloaded Image 3

End

操作系统的信号量是个很重要的概念，在进程控制方面都有应用。Java并发库的Semaphore可以很轻松完成信号量控制，Semaphore可以控制某个资源可被同时访问的个数，acquire()获取一个许可，如果没有就等待，而release()释放一个许可。比如在Windows下可以设置共享文件的最大客户端访问个数。

Semaphore维护了当前访问的个数，提供同步机制，控制同时访问的个数。在数据结构中链表可以保存“无限”的节点，用Semaphore可以实现有限大小的链表。另外重入锁ReentrantLock也可以实现该功能，但实现上要负责些，代码也要复杂些。

下面的Demo中申明了一个只有5个许可的Semaphore，而有20个线程要访问这个资源，通过acquire()和release()获取和释放访问许可。

package concurrent;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Semaphore;

public class TestSemaphore {

public static void main(String[] args) {

    // 线程池

    ExecutorService exec = Executors.newCachedThreadPool();

    // 只能5个线程同时访问

    final Semaphore semp = new Semaphore(5);

    // 模拟20个客户端访问

    for (int index = 0; index < 20; index++) {

      final int NO = index;

      Runnable run = new Runnable() {

        public void run() {

          try {

            // 获取许可

            semp.acquire();

            System.out.println("Accessing: " + NO);

            Thread.sleep((long) (Math.random() * 10000));

            // 访问完后，释放

            semp.release();

          } catch (InterruptedException e) {

          }

        }

      };

      exec.execute(run);

    }

    // 退出线程池

    exec.shutdown();

}

}

J2SE 5.0中的Java.util.concurrent程序包提供了一个新的线程框架组件，这个框架组件处理了与建立、执行和管理线程相关的很多低层细节信息。在本文中我们将细致地了解一下它的重要特性。

如果你使用C、C++或Java先前的版本进行多线程编程，就知道在代码中管理线程是多么头疼的事情。在单线程程序中，代码中引起应用程序失败的bug每次都在同一个点出现。但是在多线程程序中，只有某些原因遇到一起的时候才会出现失败。由于预见可能引发应用程序失败的所有条件是非常困难的，所以多线程编程是有挑战性的。有些程序员从根本上避免这种挑战，而另外一些--聪明的解决问题的人员--则一直坐在他们的计算机面前直到问题解决。