Android ExecutorService

来源：互联网发布：stringbuffer数组编辑：程序博客网时间：2024/05/16 00:29

转 http://www.eoeandroid.com/thread-210082-1-1.html

Handler+ExecutorService(线程池)+MessageQueue模式

能开线程的个数毕竟是有限的，我们总不能开很多线程，对于手机更是如此。

这个例子是使用线程池。Android拥有与Java相同的ExecutorService实现，我们就来用它。

线程池的基本思想还是一种对象池的思想，开辟一块内存空间，里面存放了众多(未死亡)的线程，池中线程执行调度由池管理器来处理。当有线程任务时，从池中取一个，执行完成后线程对象归池，这样可以避免反复创建线程对象所带来的性能开销，节省了系统的资源。

线程池的信息可以参看这篇文章：Java&Android的线程池－ExecutorService 下面的演示例子是创建一个可重用固定线程数的线程池。

核心代码

01packageghj1976.AndroidTest;
02 
03importjava.io.IOException;
04importjava.net.URL;
05importjava.util.concurrent.ExecutorService;
06importjava.util.concurrent.Executors;
07 
08importandroid.app.Activity;
09importandroid.graphics.drawable.Drawable;
10importandroid.os.Bundle;
11importandroid.os.Handler;
12importandroid.os.Message;
13importandroid.os.SystemClock;
14importandroid.util.Log;
15importandroid.widget.ImageView;
16 
17publicclass MainActivity extendsActivity {
18        @Override
19        publicvoid onCreate(Bundle savedInstanceState) {
20                super.onCreate(savedInstanceState);
21                setContentView(R.layout.main);
22                loadImage3("http://www.baidu.com/img/baidu_logo.gif", R.id.imageView1);
23                loadImage3("http://www.chinatelecom.com.cn/images/logo_new.gif",
24                                R.id.imageView2);
25                loadImage3("http://cache.soso.com/30d/img/web/logo.gif",
26                                R.id.imageView3);
27                loadImage3("http://csdnimg.cn/www/images/csdnindex_logo.gif",
28                                R.id.imageView4);
29                loadImage3("http://images.cnblogs.com/logo_small.gif",
30                                R.id.imageView5);
31        }
32 
33        privateHandler handler = newHandler();
34 
35        privateExecutorService executorService = Executors.newFixedThreadPool(5);
36 
37        // 引入线程池来管理多线程
38        privatevoid loadImage3(finalString url, finalint id) {
39                executorService.submit(newRunnable() {
40                        publicvoid run() {
41                                try{
42                                        finalDrawable drawable = Drawable.createFromStream(
43                                                        newURL(url).openStream(), "image.png");
44                                        // 模拟网络延时
45                                        SystemClock.sleep(2000);
46                                        handler.post(newRunnable() {
47                                                publicvoid run() {
48                                                        ((ImageView) MainActivity.this.findViewById(id))
49                                                                        .setImageDrawable(drawable);
50                                                }
51                                        });
52                                }catch(Exception e) {
53                                        thrownew RuntimeException(e);
54                                }
55                        }
56                });
57        }
58}

这里我们象第一步一样使用了 handler.post(new Runnable() { 更新前段显示当然是在UI主线程，我们还有 executorService.submit(new Runnable() { 来确保下载是在线程池的线程中。

Handler+ExecutorService(线程池)+MessageQueue+缓存模式

下面比起前一个做了几个改造:

把整个代码封装在一个类中
为了避免出现同时多次下载同一幅图的问题,使用了本地缓存

封装的类:

01packageghj1976.AndroidTest;
02 
03importjava.lang.ref.SoftReference;
04importjava.net.URL;
05importjava.util.HashMap;
06importjava.util.Map;
07importjava.util.concurrent.ExecutorService;
08importjava.util.concurrent.Executors;
09 
10importandroid.graphics.drawable.Drawable;
11importandroid.os.Handler;
12importandroid.os.SystemClock;
13 
14publicclass AsyncImageLoader3 {
15        // 为了加快速度，在内存中开启缓存（主要应用于重复图片较多时，或者同一个图片要多次被访问，比如在ListView时来回滚动）
16        publicMap<String, SoftReference<Drawable>> imageCache = newHashMap<String, SoftReference<Drawable>>();
17         
18        privateExecutorService executorService = Executors.newFixedThreadPool(5);// 固定五个线程来执行任务
19        privatefinal Handler handler = newHandler();
20 
21        /**
22         *
23         * @param imageUrl
24         *            图像url地址
25         * @param callback
26         *            回调接口
27         * <a href="\"http://www.eoeandroid.com/home.php?mod=space&uid=7300\"" target="\"_blank\"">@return</a> 返回内存中缓存的图像，第一次加载返回null
28         */
29        publicDrawable loadDrawable(finalString imageUrl,
30                        finalImageCallback callback) {
31                // 如果缓存过就从缓存中取出数据
32                if(imageCache.containsKey(imageUrl)) {
33                        SoftReference<Drawable> softReference = imageCache.get(imageUrl);
34                        if(softReference.get() != null) {
35                                returnsoftReference.get();
36                        }
37                }
38                // 缓存中没有图像，则从网络上取出数据，并将取出的数据缓存到内存中
39                executorService.submit(newRunnable() {
40                        publicvoid run() {
41                                try{
42                                        finalDrawable drawable = loadImageFromUrl(imageUrl); 
43                                                 
44                                        imageCache.put(imageUrl,newSoftReference<Drawable>(
45                                                        drawable));
46 
47                                        handler.post(newRunnable() {
48                                                publicvoid run() {
49                                                        callback.imageLoaded(drawable);
50                                                }
51                                        });
52                                }catch(Exception e) {
53                                        thrownew RuntimeException(e);
54                                }
55                        }
56                });
57                returnnull;
58        }
59 
60        // 从网络上取数据方法
61        protectedDrawable loadImageFromUrl(String imageUrl) {
62                try{
63                        // 测试时，模拟网络延时，实际时这行代码不能有
64                        SystemClock.sleep(2000);
65 
66                        returnDrawable.createFromStream(newURL(imageUrl).openStream(),
67                                        "image.png");
68 
69                }catch(Exception e) {
70                        thrownew RuntimeException(e);
71                }
72        }
73 
74        // 对外界开放的回调接口
75        publicinterface ImageCallback {
76                // 注意 此方法是用来设置目标对象的图像资源
77                publicvoid imageLoaded(Drawable imageDrawable);
78        }
79}

说明：

final参数是指当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。参看：Java关键字final、static使用总结
这里使用SoftReference 是为了解决内存不足的错误（OutOfMemoryError）的，更详细的可以参看：内存优化的两个类:SoftReference 和 WeakReference

前段调用:

view source
01packageghj1976.AndroidTest;
02 
03importandroid.app.Activity;
04importandroid.graphics.drawable.Drawable;
05importandroid.os.Bundle;
06 
07importandroid.widget.ImageView;
08 
09publicclass MainActivity extendsActivity {
10        @Override
11        publicvoid onCreate(Bundle savedInstanceState) {
12                super.onCreate(savedInstanceState);
13                setContentView(R.layout.main);
14                loadImage4("http://www.baidu.com/img/baidu_logo.gif", R.id.imageView1);
15                loadImage4("http://www.chinatelecom.com.cn/images/logo_new.gif",
16                                R.id.imageView2);
17                loadImage4("http://cache.soso.com/30d/img/web/logo.gif",
18                                R.id.imageView3);
19                loadImage4("http://csdnimg.cn/www/images/csdnindex_logo.gif",
20                                R.id.imageView4);
21                loadImage4("http://images.cnblogs.com/logo_small.gif",
22                                R.id.imageView5);
23        }
24 
25        privateAsyncImageLoader3 asyncImageLoader3 = newAsyncImageLoader3();
26 
27        // 引入线程池，并引入内存缓存功能,并对外部调用封装了接口，简化调用过程
28        privatevoid loadImage4(finalString url, finalint id) {
29                // 如果缓存过就会从缓存中取出图像，ImageCallback接口中方法也不会被执行
30                Drawable cacheImage = asyncImageLoader3.loadDrawable(url,
31                                newAsyncImageLoader3.ImageCallback() {
32                                        // 请参见实现：如果第一次加载url时下面方法会执行
33                                        publicvoid imageLoaded(Drawable imageDrawable) {
34                                                ((ImageView) findViewById(id))
35                                                                .setImageDrawable(imageDrawable);
36                                        }
37                                });
38                if(cacheImage != null) {
39                        ((ImageView) findViewById(id)).setImageDrawable(cacheImage);
40                }
41        }
42 
43}

0 0