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程序包提供了一个新的线程框架组件,这个框架组件处理了与建立、执行和管理线程相关的很多低层细节信息。在本文中我们将细致地了解一下它的重要特性。

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

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值