- 浏览: 236177 次
- 性别:
- 来自: 北京
文章分类
最新评论
-
ly8666:
十分感谢。。谢谢
一个完整的混合加密方式在Socket客户机服务器通信应用中的例子 -
blaiu:
打个包传上来?
用CSS实现下拉菜单的多种方法 -
kk_luan:
至支持IE,但不能支持IE9
JavaScript关闭当前网页,不用提示 -
lishaorui:
刚好需要,试了下,很好。
android技巧:apk文件反编译以及签名打包(dex2jar&jd,apktool,apk-sign) -
shaopengxiang:
有没有源码哈? 能共享吗?
DroidInfo v0.2.1 手机信息查询应用
A good practice in creating responsive applications is to make sure your main UI thread does the minimum amount of work. Any potentially long task that may hang your application should be handled in a different thread. Typical examples of such tasks are network operations, which involve unpredictable delays. Users will tolerate some pauses, especially if you provide feedback that something is in progress, but a frozen application gives them no clue. In this article, we will create a simple image downloader that illustrates this pattern. We will populate a ListView with thumbnail images downloaded from the internet. Creating an asynchronous task that downloads in the background will keep our application fast. Downloading an image from the web is fairly simple, using the HTTP-related classes provided by the framework. Here is a possible implementation: A client and an HTTP request are created. If the request succeeds, the response entity stream containing the image is decoded to create the resulting Bitmap. Your applications' manifest must ask for the Note: a bug in the previous versions of This ensures that skip() actually skips the provided number of bytes, unless we reach the end of file. If you were to directly use this method in your ListAdapter's getView method, the resulting scrolling would be unpleasantly jaggy. Each display of a new view has to wait for an image download, which prevents smooth scrolling. Indeed, this is such a bad idea that the AndroidHttpClient does not allow itself to be started from the main thread. The above code will display "This thread forbids HTTP requests" error messages instead. Use the DefaultHttpClient instead if you really want to shoot yourself in the foot. The The The This simplified example illustrates the use on an However, a ListView-specific behavior reveals a problem with our current implementation. Indeed, for memory efficiency reasons, ListView recycles the views that are displayed when the user scrolls. If one flings the list, a given ImageView object will be used many times. Each time it is displayed the ImageView correctly triggers an image download task, which will eventually change its image. So where is the problem? As with most parallel applications, the key issue is in the ordering. In our case, there's no guarantee that the download tasks will finish in the order in which they were started. The result is that the image finally displayed in the list may come from a previous item, which simply happened to have taken longer to download. This is not an issue if the images you download are bound once and for all to given ImageViews, but let's fix it for the common case where they are used in a list. To solve this issue, we should remember the order of the downloads, so that the last started one is the one that will effectively be displayed. It is indeed sufficient for each ImageView to remember its last download. We will add this extra information in the ImageView using a dedicated Drawable subclass, which will be temporarily bind to the ImageView while the download is in progress. Here is the code of our This implementation is backed by a Let's change our code to take this new class into account. First, the The This method uses a helper Finally, With these modifications, our The source code of this article is available online on Google Code. You can switch between and compare the three different implementations that are described in this article (no asynchronous task, no bitmap to task association and the final correct version). Note that the cache size has been limited to 10 images to better demonstrate the issues. This code was simplified to focus on its parallel aspects and many useful features are missing from our implementation. The Download errors and time-outs are correctly handled by our implementation, which will return a Our HTTP request is pretty simple. One may want to add parameters or cookies to the request as required by certain web sites. The AsyncTask class used in this article is a really convenient and easy way to defer some work from the UI thread. You may want to use the An Image downloader
static Bitmap downloadBitmap(String url) {
final AndroidHttpClient client = AndroidHttpClient.newInstance("Android");
final HttpGet getRequest = new HttpGet(url);
try {
HttpResponse response = client.execute(getRequest);
final int statusCode = response.getStatusLine().getStatusCode();
if (statusCode != HttpStatus.SC_OK) {
Log.w("ImageDownloader", "Error " + statusCode + " while retrieving bitmap from " + url);
return null;
}
final HttpEntity entity = response.getEntity();
if (entity != null) {
InputStream inputStream = null;
try {
inputStream = entity.getContent();
final Bitmap bitmap = BitmapFactory.decodeStream(inputStream);
return bitmap;
} finally {
if (inputStream != null) {
inputStream.close();
}
entity.consumeContent();
}
}
} catch (Exception e) {
// Could provide a more explicit error message for IOException or IllegalStateException
getRequest.abort();
Log.w("ImageDownloader", "Error while retrieving bitmap from " + url, e.toString());
} finally {
if (client != null) {
client.close();
}
}
return null;
}
INTERNET
to make this possible.BitmapFactory.decodeStream
may prevent this code from working over a slow connection. Decode a new FlushedInputStream(inputStream)
instead to fix the problem. Here is the implementation of this helper class:static class FlushedInputStream extends FilterInputStream {
public FlushedInputStream(InputStream inputStream) {
super(inputStream);
}
@Override
public long skip(long n) throws IOException {
long totalBytesSkipped = 0L;
while (totalBytesSkipped < n) {
long bytesSkipped = in.skip(n - totalBytesSkipped);
if (bytesSkipped == 0L) {
int byte = read();
if (byte < 0) {
break; // we reached EOF
} else {
bytesSkipped = 1; // we read one byte
}
}
totalBytesSkipped += bytesSkipped;
}
return totalBytesSkipped;
}
}
Introducing asynchronous tasks
AsyncTask
class provides one of the simplest ways to fire off a new task from the UI thread. Let's create anImageDownloader
class which will be in charge of creating these tasks. It will provide a download
method which will assign an image downloaded from its URL to an ImageView
:public class ImageDownloader {
public void download(String url, ImageView imageView) {
BitmapDownloaderTask task = new BitmapDownloaderTask(imageView);
task.execute(url);
}
}
/* class BitmapDownloaderTask, see below */
}
BitmapDownloaderTask
is the AsyncTask which will actually download the image. It is started using execute
, which returns immediately hence making this method really fast which is the whole purpose since it will be called from the UI thread. Here is the implementation of this class:class BitmapDownloaderTask extends AsyncTask<String, Void, Bitmap> {
private String url;
private final WeakReference<ImageView> imageViewReference;
public BitmapDownloaderTask(ImageView imageView) {
imageViewReference = new WeakReference<ImageView>(imageView);
}
@Override
// Actual download method, run in the task thread
protected Bitmap doInBackground(String... params) {
// params comes from the execute() call: params[0] is the url.
return downloadBitmap(params[0]);
}
@Override
// Once the image is downloaded, associates it to the imageView
protected void onPostExecute(Bitmap bitmap) {
if (isCancelled()) {
bitmap = null;
}
if (imageViewReference != null) {
ImageView imageView = imageViewReference.get();
if (imageView != null) {
imageView.setImageBitmap(bitmap);
}
}
}
}
doInBackground
method is the one which is actually run in its own process by the task. It simply uses thedownloadBitmap
method we implemented at the beginning of this article.onPostExecute
is run in the calling UI thread when the task is finished. It takes the resulting Bitmap as a parameter, which is simply associated with the imageView that was provided to download
and was stored in theBitmapDownloaderTask
. Note that this ImageView is stored as a WeakReference
, so that a download in progress does not prevent a killed activity's ImageView from being garbage collected. This explains why we have to check that both the weak reference and the imageView
are not null (i.e. were not collected) before using them inonPostExecute
.AsyncTask
, and if you try it, you'll see that these few lines of code actually dramatically improved the performance of the ListView which now scrolls smoothly. Read Painless threading for more details on AsyncTasks.Handling concurrency
DownloadedDrawable
class:static class DownloadedDrawable extends ColorDrawable {
private final WeakReference<BitmapDownloaderTask> bitmapDownloaderTaskReference;
public DownloadedDrawable(BitmapDownloaderTask bitmapDownloaderTask) {
super(Color.BLACK);
bitmapDownloaderTaskReference =
new WeakReference<BitmapDownloaderTask>(bitmapDownloaderTask);
}
public BitmapDownloaderTask getBitmapDownloaderTask() {
return bitmapDownloaderTaskReference.get();
}
}
ColorDrawable
, which will result in the ImageView displaying a black background while its download is in progress. One could use a “download in progress” image instead, which would provide feedback to the user. Once again, note the use of a WeakReference to limit object dependencies.download
method will now create an instance of this class and associate it with the imageView:public void download(String url, ImageView imageView) {
if (cancelPotentialDownload(url, imageView)) {
BitmapDownloaderTask task = new BitmapDownloaderTask(imageView);
DownloadedDrawable downloadedDrawable = new DownloadedDrawable(task);
imageView.setImageDrawable(downloadedDrawable);
task.execute(url, cookie);
}
}
cancelPotentialDownload
method will stop the possible download in progress on this imageView since a new one is about to start. Note that this is not sufficient to guarantee that the newest download is always displayed, since the task may be finished, waiting in its onPostExecute
method, which may still may be executed after the one of this new download.private static boolean cancelPotentialDownload(String url, ImageView imageView) {
BitmapDownloaderTask bitmapDownloaderTask = getBitmapDownloaderTask(imageView);
if (bitmapDownloaderTask != null) {
String bitmapUrl = bitmapDownloaderTask.url;
if ((bitmapUrl == null) || (!bitmapUrl.equals(url))) {
bitmapDownloaderTask.cancel(true);
} else {
// The same URL is already being downloaded.
return false;
}
}
return true;
}
cancelPotentialDownload
uses the cancel
method of the AsyncTask class to stop the download in progress. It returns true
most of the time, so that the download can be started in download
. The only reason we don't want this to happen is when a download is already in progress on the same URL in which case we let it continue. Note that with this implementation, if an ImageView is garbage collected, its associated download is not stopped. A RecyclerListener
might be used for that.getBitmapDownloaderTask
function, which is pretty straigthforward:private static BitmapDownloaderTask getBitmapDownloaderTask(ImageView imageView) {
if (imageView != null) {
Drawable drawable = imageView.getDrawable();
if (drawable instanceof DownloadedDrawable) {
DownloadedDrawable downloadedDrawable = (DownloadedDrawable)drawable;
return downloadedDrawable.getBitmapDownloaderTask();
}
}
return null;
}
onPostExecute
has to be modified so that it will bind the Bitmap only if this ImageView is still associated with this download process:if (imageViewReference != null) {
ImageView imageView = imageViewReference.get();
BitmapDownloaderTask bitmapDownloaderTask = getBitmapDownloaderTask(imageView);
// Change bitmap only if this process is still associated with it
if (this == bitmapDownloaderTask) {
imageView.setImageBitmap(bitmap);
}
}
ImageDownloader
class provides the basic services we expect from it. Feel free to use it or the asynchronous pattern it illustrates in your applications to ensure their responsiveness.Demo
Future work
ImageDownloader
class would first clearly benefit from a cache, especially if it is used in conjuction with a ListView, which will probably display the same image many times as the user scrolls back and forth. This can easily be implemented using a Least Recently Used cache backed by a LinkedHashMap
of URL to Bitmap SoftReferences
. More involved cache mechanism could also rely on a local disk storage of the image. Thumbnails creation and image resizing could also be added if needed.null
Bitmap in these case. One may want to display an error image instead.Handler
class to have a finer control on what you do, such as controlling the total number of download threads which are running in parallel in this case.
发表评论
-
Sqlite3支持的数据类型 日期函数 Sqlite3 函数
2011-03-06 10:45 7457Sqlite3支持的数据类型 NULL INTEGER ... -
Android Intent 使用整理
2011-03-05 17:29 1411在一个Android应用中, ... -
ubuntu 10.10同步CyanogenMod源码报错解决
2011-02-13 13:28 2096From git://github.com/Cyanog ... -
ubuntu 10.10使用adb连接g2
2011-02-13 09:12 1819在ubuntu 10.10下通过usb连接g2,使用adb时, ... -
Android程序设置成横屏方法
2011-01-19 09:35 29701.AndroidManifest.xml设置属性:andro ... -
使用Intent启动常用的应用与服务
2010-11-29 11:25 1519以下ATAAW.COM列举了一些在Android中常用的I ... -
ubuntu10.04安装android ADT报错 :osgi.bundle,org.eclipse.cvs
2010-09-10 22:46 3373在Ubuntu下安装Eclipse的PDT插件的时候,总是 ... -
android技巧:apk文件反编译以及签名打包(dex2jar&jd,apktool,apk-sign)
2010-08-30 14:10 13080通过dex2jar和jd我们可以反编译apk中的de ... -
Android防火墙+流量统计代码
2010-06-23 12:42 3641用于监听开机信息 并初始化和启动服务 package ... -
Android 实现通话监听
2010-05-21 12:22 2928对智能手机有所了解 ... -
Android 手机制式和网络类型 GSM/EDGE/CDMA/WCDMA 判断sim卡类型 sim/uim/usim
2010-05-13 13:03 5368android 手机制式和网络类型 GSM/EDGE/CDMA ... -
android List拖动时背景为黑色问题
2010-05-04 22:23 1577在为程序加背景时,发现在拖动List或Grid列表时一片漆 ... -
android 彻底关闭应用程序 返回键的捕获
2010-04-30 00:19 26370在开发android应用时,常常通过按返回键(即keyCode ... -
android 屏幕旋转 重新调用onCreate
2010-04-28 11:09 6377最近在写个小应用的时候碰到一个问题,就是在手机屏幕自动横竖旋转 ...
相关推荐
标题“android-multithreading.rar_android_android Thread”表明此压缩包包含有关Android平台上多线程使用的详细信息,特别是针对Android线程(Thread)的实践应用。 在Android系统中,主线程(UI线程)负责处理...
Pro Multithreading and Memory Management for iOS and OS X with ARC, Grand Central Dispatch epub
supplied specifically for the purpose of being entered and executed on a computer system, for exclusive use by the purchaser of the work. Duplication of this publication or parts thereof is permitted ...
The Concurrency Utilities for simplifying multithreading Classic and New I/O Networking and database access Parsing, creating, and transforming XML documents Additional APIs for creating and accessing...
Presented in 48 concise lessons that target the most common and critical performance pitfalls, this book offers a plethora of practical tips and solutions for boosting the performance of your programs...
This book will teach you the finer points of multithreading and concurrency concepts and how to apply them efficiently in C++. Divided into three modules, we start with a brief introduction to the ...
### Pro Multithreading and Memory Management for iOS #### 内存管理和多线程在iOS开发中的重要性 在iOS开发过程中,内存管理和多线程技术是确保应用性能与稳定性的重要环节。《Pro Multithreading and Memory ...
In the following chapters, you’ll explore multithreading and asynchronous programming with C++ and Qt and learn the importance and efficient use of data structures. You’ll also get the opportunity ...
the importance of building solid applications using multithreading concurrency and multi-core device architecture is covered, before moving on to best practices and techniques that you should utilize ...
The Concurrency Utilities for simplifying multithreading Classic and New I/O Networking and database access Parsing, creating, and transforming XML documents Additional APIs for creating and accessing...
Mastering C++ Multithreading 英文epub 本资源转载自网络,如有侵权,请联系上传者或csdn删除 本资源转载自网络,如有侵权,请联系上传者或csdn删除
性能评估不仅限于提高单个程序的吞吐率,还包括响应时间、能效比(Performance-per-Watt)等。 6. **线程调度和线程选择策略**:线程调度策略决定了在任何给定的时刻哪个线程可以获得处理器资源。这包括了静态调度...
iOS多线程开发是iOS编程中极为重要的一部分,它允许开发者在应用程序中创建多个线程,从而同时执行多个任务,提高应用性能和用户体验。多线程编程技术在iOS开发中主要通过几种方式实现:NSThread类、POSIX线程(即...
### Android Cookbook:第二版——Android开发者的难题与解决方案 #### 书籍概述 《Android Cookbook》第二版是由Ian F. Darwin撰写的专为Android开发者解决实际问题的指南书籍。本书版权归属于2017年的O'Reilly ...
nt among these are those that rely heavily on multithreading, where the performance gap between native execution and virtualized execution remains significant. This article delves into the current ...