`
大象06
  • 浏览: 119473 次
  • 性别: Icon_minigender_1
  • 来自: 武汉
社区版块
存档分类
最新评论

[转载][Android实例] Handler+ExecutorService(线程池)+MessageQueue模式+缓存模式

android多线程异步handler 
阅读更多

Handler+Runnable模式

我们先看一个并不是异步线程加载的例子，使用 Handler+Runnable模式。

这里为何不是新开线程的原因请参看这篇文章：Android Runnable 运行在那个线程 这里的代码其实是在UI 主线程中下载图片的，而不是新开线程。

我们运行下面代码时，会发现他其实是阻塞了整个界面的显示，需要所有图片都加载完成后，才能显示界面

package com.example.demo;

import java.net.URL;

import android.app.Activity;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.os.Handler;
import android.os.SystemClock;
import android.util.Log;
import android.view.Menu;
import android.widget.ImageView;

public class MainActivity extends Activity {

	private static final String TAG = "[YIBU]";
	
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        loadImage("http://www.baidu.com/img/baidu_logo.gif", R.id.imageView1);
        loadImage("http://www.chinatelecom.com.cn/images/logo_new.gif",R.id.imageView2);
        loadImage("http://cache.soso.com/30d/img/web/logo.gif", R.id.imageView3);
        loadImage("http://csdnimg.cn/www/images/csdnindex_logo.gif",R.id.imageView4);
        loadImage("http://images.cnblogs.com/logo_small.gif",R.id.imageView5);
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.activity_main, menu);
        return true;
    }

    private Handler handler = new Handler();
    
    private void loadImage(final String url,final int id){
    	handler.post(new Runnable() {
			
			@Override
			public void run() {
				Drawable drawable = null;
				try {
					drawable = Drawable.createFromStream(new URL(url).openStream(), "image.gif");
				} catch (Exception e) {
					Log.d(TAG, e.getMessage());
				}
				if(drawable == null){
					Log.d(TAG, "null drawable");
				}
				
				SystemClock.sleep(2000);
				((ImageView)MainActivity.this.findViewById(id)).setImageDrawable(drawable);
			}
		});
    }
}

 

Handler+Thread+Message模式

这种模式使用了线程，所以可以看到异步加载的效果。

核心代码：

package com.example.demo;

import java.net.URL;

import android.annotation.TargetApi;
import android.app.Activity;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.os.StrictMode;
import android.os.SystemClock;
import android.util.Log;
import android.view.Menu;
import android.widget.ImageView;

@TargetApi(11)
public class MainActivity extends Activity {

	private static final String TAG = "[YIBU]";
	
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        loadImage2("http://www.baidu.com/img/baidu_logo.gif", R.id.imageView1);
        loadImage2("http://www.chinatelecom.com.cn/images/logo_new.gif",R.id.imageView2);
        loadImage2("http://cache.soso.com/30d/img/web/logo.gif", R.id.imageView3);
        loadImage2("http://csdnimg.cn/www/images/csdnindex_logo.gif",R.id.imageView4);
        loadImage2("http://images.cnblogs.com/logo_small.gif",R.id.imageView5);
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.activity_main, menu);
        return true;
    }

    
    private Handler handler2 = new Handler(){

		@Override
		public void handleMessage(Message msg) {
			((ImageView)MainActivity.this.findViewById(msg.arg1)).setImageDrawable((Drawable) msg.obj);
		}
    	
    };
    
    private void loadImage2(final String url,final int id){
    	Thread thread = new Thread(){

			@Override
			public void run() {
				Drawable drawable = null;
				try {
					drawable = Drawable.createFromStream(new URL(url).openStream(), "image.gif");
				} catch (Exception e) {
					Log.d(TAG, e.getMessage());
				}
				SystemClock.sleep(2000);
				Message message = handler2.obtainMessage();
				message.arg1 = id;
				message.obj = drawable;
				handler2.sendMessage(message);
			}
    	};
    	thread.start();
    	thread = null;
    }
    
}

 这时候我们可以看到实现了异步加载， 界面打开时，五个ImageView都是没有图的，然后在各自线程下载完后才把图自动更新上去。

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

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

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

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

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

核心代码

package com.example.demo;

import java.net.URL;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import android.annotation.TargetApi;
import android.app.Activity;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.os.Handler;
import android.os.SystemClock;
import android.view.Menu;
import android.widget.ImageView;

public class MainActivity extends Activity {

	private static final String TAG = "[YIBU]";

	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		loadImage3("http://www.baidu.com/img/baidu_logo.gif", R.id.imageView1);
		loadImage3("http://www.chinatelecom.com.cn/images/logo_new.gif",R.id.imageView2);
		loadImage3("http://cache.soso.com/30d/img/web/logo.gif",R.id.imageView3);
		loadImage3("http://csdnimg.cn/www/images/csdnindex_logo.gif",R.id.imageView4);
		loadImage3("http://images.cnblogs.com/logo_small.gif", R.id.imageView5);
	}

	@Override
	public boolean onCreateOptionsMenu(Menu menu) {
		getMenuInflater().inflate(R.menu.activity_main, menu);
		return true;
	}

	private Handler handler = new Handler();

	private ExecutorService executorService = Executors.newFixedThreadPool(5);

	// 引入线程池来管理多线程
	private void loadImage3(final String url, final int id) {
		executorService.submit(new Runnable() {
			public void run() {
				try {
					final Drawable drawable = Drawable.createFromStream(
							new URL(url).openStream(), "image.png");
					// 模拟网络延时
					SystemClock.sleep(2000);
					handler.post(new Runnable() {
						public void run() {
							((ImageView) MainActivity.this.findViewById(id))
									.setImageDrawable(drawable);
						}
					});
				} catch (Exception e) {
					throw new RuntimeException(e);
				}
			}
		});
	}

}

 

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

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

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

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

封装的类:

package ghj1976.AndroidTest;
 
import java.lang.ref.SoftReference;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
import android.graphics.drawable.Drawable;
import android.os.Handler;
import android.os.SystemClock;
 
public class AsyncImageLoader3 {
        // 为了加快速度，在内存中开启缓存（主要应用于重复图片较多时，或者同一个图片要多次被访问，比如在ListView时来回滚动）
        public Map<String, SoftReference<Drawable>> imageCache = new HashMap<String, SoftReference<Drawable>>();
         
        private ExecutorService executorService = Executors.newFixedThreadPool(5); // 固定五个线程来执行任务
        private final Handler handler = new Handler();
 
        /**
         * 
         * @param imageUrl
         *            图像url地址
         * @param callback
         *            回调接口
         * <a href="\"http://www.eoeandroid.com/home.php?mod=space&uid=7300\"" target="\"_blank\"">@return</a> 返回内存中缓存的图像，第一次加载返回null
         */
        public Drawable loadDrawable(final String imageUrl,
                        final ImageCallback callback) {
                // 如果缓存过就从缓存中取出数据
                if (imageCache.containsKey(imageUrl)) {
                        SoftReference<Drawable> softReference = imageCache.get(imageUrl);
                        if (softReference.get() != null) {
                                return softReference.get();
                        }
                }
                // 缓存中没有图像，则从网络上取出数据，并将取出的数据缓存到内存中
                executorService.submit(new Runnable() {
                        public void run() {
                                try {
                                        final Drawable drawable = loadImageFromUrl(imageUrl); 
                                                 
                                        imageCache.put(imageUrl, new SoftReference<Drawable>(
                                                        drawable));
 
                                        handler.post(new Runnable() {
                                                public void run() {
                                                        callback.imageLoaded(drawable);
                                                }
                                        });
                                } catch (Exception e) {
                                        throw new RuntimeException(e);
                                }
                        }
                });
                return null;
        }
 
        // 从网络上取数据方法
        protected Drawable loadImageFromUrl(String imageUrl) {
                try {
                        // 测试时，模拟网络延时，实际时这行代码不能有
                        SystemClock.sleep(2000);
 
                        return Drawable.createFromStream(new URL(imageUrl).openStream(),
                                        "image.png");
 
                } catch (Exception e) {
                        throw new RuntimeException(e);
                }
        }
 
        // 对外界开放的回调接口
        public interface ImageCallback {
                // 注意 此方法是用来设置目标对象的图像资源
                public void imageLoaded(Drawable imageDrawable);
        }
}

 说明：

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

前段调用:

package ghj1976.AndroidTest;
 
import android.app.Activity;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
 
import android.widget.ImageView;
 
public class MainActivity extends Activity {
        @Override
        public void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.main);
                loadImage4("http://www.baidu.com/img/baidu_logo.gif", R.id.imageView1);
                loadImage4("http://www.chinatelecom.com.cn/images/logo_new.gif",
                                R.id.imageView2);
                loadImage4("http://cache.soso.com/30d/img/web/logo.gif",
                                R.id.imageView3);
                loadImage4("http://csdnimg.cn/www/images/csdnindex_logo.gif",
                                R.id.imageView4);
                loadImage4("http://images.cnblogs.com/logo_small.gif",
                                R.id.imageView5);
        }
 
        private AsyncImageLoader3 asyncImageLoader3 = new AsyncImageLoader3();
 
        // 引入线程池，并引入内存缓存功能,并对外部调用封装了接口，简化调用过程
        private void loadImage4(final String url, final int id) {
                // 如果缓存过就会从缓存中取出图像，ImageCallback接口中方法也不会被执行
                Drawable cacheImage = asyncImageLoader3.loadDrawable(url,
                                new AsyncImageLoader3.ImageCallback() {
                                        // 请参见实现：如果第一次加载url时下面方法会执行
                                        public void imageLoaded(Drawable imageDrawable) {
                                                ((ImageView) findViewById(id))
                                                                .setImageDrawable(imageDrawable);
                                        }
                                });
                if (cacheImage != null) {
                        ((ImageView) findViewById(id)).setImageDrawable(cacheImage);
                }
        }
 
}

 

分享到：
| Android中采用XmlPullParser解析xml文件 ...
评论
2 楼 985996546 2015-11-17  
1 楼 fategaga 2014-04-12  
drawable = Drawable.createFromStream(new URL(url).openStream(), "image.gif");  这句话报错啊!
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Handler+Looper+MessageQueue

    【Android 线程间通信：Handler、Looper 和 MessageQueue 深度解析】 在 Android 应用开发中，为了保证界面的流畅性，我们通常需要将耗时操作放在非 UI 线程中执行，然后通过某种机制将结果传递回 UI 线程进行界面...

    Android 异步处理 Handler+Looper+MessageQueue深入详解

    Handler、Looper和MessageQueue是Android异步处理机制中的核心组件，它们共同构建了一个消息传递系统，使得在不同线程间进行数据交换变得可能。下面我们将深入探讨这三个组件的工作原理及其在实际开发中的应用。 ...

    Handler Looper MessageQueue 源码解析

    在Android系统中，Handler、Looper和MessageQueue是实现线程间通信的核心组件，它们共同构建了一个消息处理机制。本文将深入解析这三者的源码，帮助你理解它们的工作原理，并教你如何手写一套自己的Handler系统。 ...

    Message,MessageQueue,Looper,Handler详解

    综上所述，Message、MessageQueue、Looper和Handler这四个组件共同构成了Android应用程序中处理消息的基本机制。通过它们之间的相互协作，使得应用程序能够在不同的线程间高效地传递和处理消息，从而实现了复杂的...

    android 线程池 handler异步刷新 双缓存

    在实际项目中，我们可以封装一个工具类或服务类，包含初始化线程池、创建Handler实例、异步加载数据到双缓存、以及在主线程更新UI的方法。例如，我们可以创建一个`AsyncDataFetcher`类，包含`fetchData()`方法负责...

    Handler+Looper+MessageQueue+Message机制

    Message（消息）：需要被传递的消息，其中包含了消息标识(what)，消息处理数据和处理对象(arg1，arg2，obj)，发送该消息的Handler对象(target)等，由MessageQueue统一列队，最终由Handler处理。 MessageQueue（消息...

    活用Android的Message Queue

    理解并熟练运用Message Queue、Looper和Handler是构建高效、响应性良好的Android应用的关键。 1. **Message Queue（消息队列）的角色** - 每个线程不自动创建Message Loop，需要手动通过Looper类来建立。 - ...

    Thread,Looper,Handler,Message,MessageQueue,MessagePool之间的关系

    在Android系统中，线程（Thread）、Looper、Handler、Message以及MessageQueue和MessagePool是实现异步消息处理机制的关键组件，它们共同构建了一个高效的事件驱动模型。这些组件的关系紧密，协同工作，使得Android...

    Handler+Thread

    一个`Handler`对象通常与特定的`Looper`和`MessageQueue`关联，`Looper`循环地从`MessageQueue`中取出消息并分发给相应的`Handler`进行处理。这样，我们可以在工作线程中执行耗时任务，然后通过`Handler`将结果发送...

    Android的消息处理机制--Message，MessageQueue

    4. **Looper**：充当MessageQueue和Handler之间的桥梁角色，负责循环取出MessageQueue中的消息，并交给对应的Handler处理。 #### 四、消息处理流程 1. **创建Handler**：每个需要处理消息的线程都需要一个Handler...

    Android Handler模拟线程池实现照片墙

    Android Handler模拟线程池并发下载网络图片实现照片墙

    Android 之 Looper、MessageQueue、Handler 与消息循环

    - **初始化**：通过`Looper.prepare()`方法初始化Looper对象，这一步会在当前线程内部创建一个MessageQueue实例。 - **消息循环**：通过调用`Looper.loop()`方法进入消息循环状态。在这个方法中，会不断从Message...

    android MessageQueue

    在Android系统中，MessageQueue是消息机制的核心组件之一，它与Handler、Looper紧密协作，用于实现线程间的通信。理解MessageQueue的工作原理对于优化应用程序性能和处理异步操作至关重要。 MessageQueue是一个内部...

    handler与looper及messagequeue的简单总结

    在Android开发中，Handler、Looper和MessageQueue是用于实现线程间通信的关键组件，它们共同构建了一个消息处理机制。理解这三个概念以及它们之间的关系对于优化应用程序的性能和响应性至关重要。 Handler（处理器...

    android线程 Handler Message Queue AsyncTask线程模型 线程交互 + 修改Button样式 示例 最终easy整合版

    以上就是关于Android线程模型和线程交互的详解，包括Handler、Message Queue和AsyncTask的使用，以及修改Button样式的实例。理解并熟练运用这些技术，可以极大地提高Android应用的性能和用户体验。通过不断实践和...

    Android单线程模型中Message、Handler、Message Queue、Looper之间的关系---附实例源码

    Handler获取当前线程中的looper对象，looper用来从存放Message的MessageQueue中取出Message，再有Handler进行Message的分发和处理. 简单定义： 1、Message Queue(消息队列)： 用来存放通过Handler发布的消息，通常...

    线程，线程池与Handler的用法

    在Android开发中，线程和线程池是处理异步任务的重要工具，而Handler则是用于在主线程和子线程之间通信的关键组件。本篇文章将深入探讨这些概念，以及它们在实际应用中的用法。 首先，让我们理解什么是线程。线程是...

    中高级专题（View+Handler+Binder）.zip

    【标题】"中高级专题（View+Handler+Binder）" 这个标题所指的"中高级专题...而提供的"中高级专题（View+Handler+Binder）.docx"文档，很可能是对这些概念的详细讲解和实例分析，对开发者来说是一份宝贵的参考资料。

    Handler+Service+Broadcast+ListView的综合使用

    一个将Handler+Service+Broadcast+ListView一起综合起来使用的工程，可以帮助更熟练的使用Service和Broadcast以及ListView，对Handler的了解及运行机制更深入的了解~

Magicbox
Global site tag (gtag.js) - Google Analytics