我们需要用到android-sdk开发包中adb shell
进入Android SDK中的platform-tools目录,然后运行命令:adb shell
然后再输入:
setprop net.dns IP(输入你的局域网地址)
getprop
退出adb shell
exit
很多Android开发者可能发现,将Bitmap转为字节数组可能文件大小和原始图片差异很大,代码如下
1. 字节数组data保存Bitmap对象转为字节数组,处理代码:
BitmapFactory.decodeByteArray(data, 0, data.length);
2. 而第二种方法处理代码:
ByteArrayOutputStream baos = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.JPEG, 100, baos);
data2 = baos.toByteArray();
这里其实很好理解,第二种方法使用了Bitmap的compress方法,一般用于保存一个Bitmap对象,转为字节输出流,但是compress目前编码由两种,比如JPG,一般处理照片和PNG,PNG一般处理带Alpha透明通道的图片,后面的第二个参数是清晰度,一般100是最高,0是最低,这个值越大图片越清晰,同时文件体积越大,JPG和PNG都是压缩的图片,所以和原始的直接通过BitmapFactory.decodeByteArray解码后的大小会有很大的不同。
ExecutorService 建立多线程的步骤:
1。定义线程类 | class Handler implements Runnable{ } |
2。建立ExecutorService线程池 | ExecutorService executorService = Executors.newCachedThreadPool(); 或者 int cpuNums = Runtime.getRuntime().availableProcessors(); //获取当前系统的CPU 数目 ExecutorService executorService =Executors.newFixedThreadPool(cpuNums * POOL_SIZE); //ExecutorService通常根据系统资源情况灵活定义线程池大小 |
3。调用线程池操作 | 循环操作,成为daemon,把新实例放入Executor池中 while(true){ executorService.execute(new Handler(socket)); // class Handler implements Runnable{ 或者 executorService.execute(createTask(i)); //private static Runnable createTask(final int taskID) } execute(Runnable对象)方法 其实就是对Runnable对象调用start()方法 (当然还有一些其他后台动作,比如队列,优先级,IDLE timeout,active激活等) |
几种不同的ExecutorService线程池对象
1.newCachedThreadPool() | -缓存型池子,先查看池中有没有以前建立的线程,如果有,就reuse.如果没有,就建一个新的线程加入池中 -缓存型池子通常用于执行一些生存期很短的异步型任务 因此在一些面向连接的daemon型SERVER中用得不多。 -能reuse的线程,必须是timeout IDLE内的池中线程,缺省timeout是60s,超过这个IDLE时长,线程实例将被终止及移出池。 注意,放入CachedThreadPool的线程不必担心其结束,超过TIMEOUT不活动,其会自动被终止。 |
2. newFixedThreadPool | -newFixedThreadPool与cacheThreadPool差不多,也是能reuse就用,但不能随时建新的线程 -其独特之处:任意时间点,最多只能有固定数目的活动线程存在,此时如果有新的线程要建立,只能放在另外的队列中等待,直到当前的线程中某个线程终止直接被移出池子 -和cacheThreadPool不同,FixedThreadPool没有IDLE机制(可能也有,但既然文档没提,肯定非常长,类似依赖上层的TCP或UDP IDLE机制之类的),所以FixedThreadPool多数针对一些很稳定很固定的正规并发线程,多用于服务器 -从方法的源代码看,cache池和fixed 池调用的是同一个底层池,只不过参数不同: fixed池线程数固定,并且是0秒IDLE(无IDLE) cache池线程数支持0-Integer.MAX_VALUE(显然完全没考虑主机的资源承受能力),60秒IDLE |
3.ScheduledThreadPool | -调度型线程池 -这个池子里的线程可以按schedule依次delay执行,或周期执行 |
4.SingleThreadExecutor | -单例线程,任意时间池中只能有一个线程 -用的是和cache池和fixed池相同的底层池,但线程数目是1-1,0秒IDLE(无IDLE) |
上面四种线程池,都使用Executor的缺省线程工厂建立线程,也可单独定义自己的线程工厂
下面是缺省线程工厂代码:
static class DefaultThreadFactory implements ThreadFactory { static final AtomicInteger poolNumber = new AtomicInteger(1); final ThreadGroup group; final AtomicInteger threadNumber = new AtomicInteger(1); final String namePrefix; DefaultThreadFactory() { SecurityManager s = System.getSecurityManager(); group = (s != null)? s.getThreadGroup() :Thread.currentThread().getThreadGroup(); namePrefix = "pool-" + poolNumber.getAndIncrement() + "-thread-"; } public Thread newThread(Runnable r) { Thread t = new Thread(group, r,namePrefix + threadNumber.getAndIncrement(),0); if (t.isDaemon()) t.setDaemon(false); if (t.getPriority() != Thread.NORM_PRIORITY) t.setPriority(Thread.NORM_PRIORITY); return t; } } |
也可自己定义ThreadFactory,加入建立池的参数中
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) { |
Executor的execute()方法
execute() 方法将Runnable实例加入pool中,并进行一些pool size计算和优先级处理
execute() 方法本身在Executor接口中定义,有多个实现类都定义了不同的execute()方法
如ThreadPoolExecutor类(cache,fiexed,single三种池子都是调用它)的execute方法如下:
public void execute(Runnable command) { if (command == null) throw new NullPointerException(); if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) { if (runState == RUNNING && workQueue.offer(command)) { if (runState != RUNNING || poolSize == 0) ensureQueuedTaskHandled(command); } else if (!addIfUnderMaximumPoolSize(command)) reject(command); // is shutdown or saturated } } |
class SimpleThreadFactory implements ThreadFactory {
public Thread newThread(Runnable r) {
return new Thread(r);
}
}
|
package com.zj.concurrency.executors;
public class MyThread
implements Runnable {
private int count = 1, number;
public MyThread(
int num) {
number = num;
System.
out.println("Create Thread-" + number);
}
public void run() {
while (
true) {
System.
out.println("Thread-" + number + " run " + count+" time(s)");
if (++count == 3)
return;
}
}
}
|
package com.zj.concurrency.executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CachedThreadPool {
public static void main(String[] args) {
ExecutorService exec = Executors.
newCachedThreadPool();
for (
int i = 0; i < 5; i++)
exec.execute(
new MyThread(i));
exec.shutdown();
}
}
|
package com.zj.concurrency.executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class FixedThreadPool {
public static void main(String[] args) {
ExecutorService exec = Executors.
newFixedThreadPool(2);
for (
int i = 0; i < 5; i++)
exec.execute(
new MyThread(i));
exec.shutdown();
}
}
|
package com.zj.concurrency.executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class SingleThreadExecutor {
public static void main(String[] args) {
ExecutorService exec = Executors.
newSingleThreadExecutor();
for (
int i = 0; i < 5; i++)
exec.execute(
new MyThread(i));
exec.shutdown();
}
}
|
package com.zj.concurrency.executors.factory;
import java.util.concurrent.ThreadFactory;
public class DaemonThreadFactory
implements ThreadFactory {
public Thread newThread(Runnable r) {
Thread t =
new Thread(r);
t.setDaemon(
true);
return t;
}
}
|
package com.zj.concurrency.executors.factory;
import java.util.concurrent.ThreadFactory;
public class MaxPriorityThreadFactory
implements ThreadFactory {
public Thread newThread(Runnable r) {
Thread t =
new Thread(r);
t.setPriority(Thread.
MAX_PRIORITY);
return t;
}
}
|
package com.zj.concurrency.executors.factory;
import java.util.concurrent.ThreadFactory;
public class MinPriorityThreadFactory
implements ThreadFactory {
public Thread newThread(Runnable r) {
Thread t =
new Thread(r);
t.setPriority(Thread.
MIN_PRIORITY);
return t;
}
}
|
package com.zj.concurrency.executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import com.zj.concurrency.executors.factory.DaemonThreadFactory;
import com.zj.concurrency.executors.factory.MaxPriorityThreadFactory;
import com.zj.concurrency.executors.factory.MinPriorityThreadFactory;
public class ExecFromFactory {
public static void main(String[] args)
throws Exception {
ExecutorService defaultExec = Executors.
newCachedThreadPool();
ExecutorService daemonExec = Executors
.
newCachedThreadPool(
new DaemonThreadFactory());
ExecutorService maxPriorityExec = Executors
.
newCachedThreadPool(
new MaxPriorityThreadFactory());
ExecutorService minPriorityExec = Executors
.
newCachedThreadPool(
new MinPriorityThreadFactory());
for (
int i = 0; i < 10; i++)
daemonExec.execute(
new MyThread(i));
for (
int i = 10; i < 20; i++)
if (i == 10)
maxPriorityExec.execute(
new MyThread(i));
else if (i == 11)
minPriorityExec.execute(
new MyThread(i));
else
defaultExec.execute(
new MyThread(i));
}
}
|
本文出自 “子 孑” 博客,请务必保留此出处http://zhangjunhd.blog.51cto.com/113473/70068
handler.post(r)其实这样并不会新起线程,只是执行的runnable里的run()方法,却没有执行start()方法,所以runnable走的还是UI线程。
1.如果像这样,是可以操作ui,但是run还是走在主线程,见打印出来的Log线程名字是main,说明是主线程。
这就是为什么可以直接在run方法里操作ui,因为它本质还是ui线程
handler.post(new Runnable(){
public void run(){
Log.e("当前线程:",Thread.currrentThread.getName());//这里打印de结果会是main
setTitle("哈哈");
}
});
2.通过HandlerThread获取到looper却是可以新起线程,但是在这里的run方法里操作ui是不可能的,但是这显然有个缺点,如果你执行多次post(r)方法其实走的还是HandlerThread线程。假如你执行5次,n次,其实还是一次并且它们是串行的。假如下载5张图片,你会看到图片是下完第一张,才会去下第二张。
实践证明,只有是拥有主线程looper的handler才可以操作ui,而在主线程操作ui可以在handler的handlerMessage()方法中操作Ui,也可以在handler的post(r)的run方法里操作Ui.
HandlerThread ht = new HandlerThread("handler thread");
ht.start();
handler = new Handler(ht.getLooper());
handler.post(new Runnable(){//这里run()方法其实还是在等ht.start()调用
public void run(){
Log.e("当前线程:",Thread.currrentThread.getName());//这里打印的会是handler thread
setTitle("哈哈");//这样必定报错
//android.view.ViewRoot$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.
}
});
这样该怎么办呢,呵呵,可以无参构建一个handler。用这个handler来发送消息和处理消息,用上面的handler来开启新线程。
mainHandler = new Handler(){
protecket void handlerMessage(Message msg){
setTitle("哈哈");//这样就不会报错啦
}
}
handler.post(new Runnable(){//这里run()方法其实还是在等ht.start()调用
public void run(){
Log.e("当前线程:",Thread.currrentThread.getName());//这里打印的会是handler thread
mainHandler.sendEmpetMessage();//用mainHandler来发送消息
//setTitle("哈哈");//这样必定报错
//android.view.ViewRoot$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.
}
});
打印Log:
3.其实第2个方法显得麻烦而且低效,用了2个handler,一个用来发起线程,一个用于处理消息。发起线程的handler必须拥有looper,所以还要实例化一个HanderThread;而处理消息的handler则不需要looper,因为它默认拥有主线程的looper,所以可以在这个handler处理ui。
其实可以只需要实例化一个handler,在主线程里构建一个无参的handler,然后由它发送和处理消息。而创建线程的任务就不用handler了,直接用new Thread(r).start();然后在r的run()方法里面处理逻辑事务。
用这样的模式下载5张图片,你就可能不会看到图片一张挨着一张展示出来,可能第2张先出来,也可能同时出来3张,5条线程很随机的。
private void loadImagesByThread(final String url,final int id){//通过Thread来new 出多个线程 new Thread(new Runnable(){ @Override public void run() { // TODO Auto-generated method stub Log.e("当前线程:", ""+Thread.currentThread().getName()); Drawable drawable = null; try { drawable = Drawable.createFromStream(new URL(url).openStream(), "image.gif"); } catch (MalformedURLException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } Message msg = mainHandler.obtainMessage(); msg.what = 2012; msg.arg1 = id; msg.obj = drawable; msg.sendToTarget(); } }).start(); }
打印Log:
4.AsyncTask
用异步任务架构多任务模型其实也不是很健壮,得创建多个AsyncTask实例。一个AsyncTask仅执行一次,不能重复执行,快餐类的线程,一次用完。
实现AsyncTask子类,最重要的两个方法,一个是doInBackground(params);一个是onPostExecute(result)。在doInBackground()方法里处理耗时事务,并把结果返回,返回的值将在onPostExecute方法作为参数,然后就可以在onPostExecute()把结果展示在ui上面了。
步骤:
①实例化AsyncTask:
实例化AsyncTask然后通过task.exec(pamas);传进去参数,这个参数列表是动态的,可以是一个也可以使多个,长度可变。
AsyncTask<params,values,reslut>,第一个参数会传进去这个方法doInBackground(params),第二个参数是数据更新的值,第三个是处理事务返回的结果。
②onPreExecute方法:
这个方法没有参数,也没有返回值,可以在这个方法里,做一些提醒。比如show一个Dialog,或者弹个Toast告诉用户开始下载啦。
③doInBackground(params)方法:
进入AsyncTask内部结构,首先将执行reslut doInBackground(params)方法,这个方法将处理耗时事务,exec()的参数将会传进这个方法做参数,而返回值将会作为onPostExecute()的参数。如果要更新进度的话,需执行publicProgress()方法。
④onProgressUpdate(values)方法:
这个方法的参数必须在doInBackground()方法里执行publicProgress()方法,这个方法将会把参数传递进onProgressUpdate()方法里,然后可以在这个方法做一些ui上的更新展示,比如进度条的值就可以通过这个values值动态改变。
⑤onPostExecute(result)方法:
这里就是事务处理完毕的走的方法,doInBackground方法执行的结果将传到这里,如果这个方法返回了数据。在这个方法里可以处理Ui,可以把处理完的数据展示在ui上。比如图片啊,文字啊,一切你想要的结果。
private void loadImageByAsyncTask(final String url,final int id){//构建异步任务,这样就不用handler来处理消息了 DownloadTask task = new DownloadTask(); task.execute(""+id,url);//AsyncTask不可重复执行 } class DownloadTask extends AsyncTask<String,Integer,Drawable>{ int id; @Override protected Drawable doInBackground(String... params) {//params保存url和控件id两个数据 // TODO Auto-generated method stub Log.e("当前线程:", ""+Thread.currentThread().getName()); Drawable drawable = null; this.id = Integer.parseInt(params[0]); try { drawable = Drawable.createFromStream(new URL(params[1]).openStream(), "image.gif"); } catch (MalformedURLException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } return drawable; } @Override protected void onPostExecute(Drawable result) { // TODO Auto-generated method stub super.onPostExecute(result); ((ImageView)MainActivity.this.findViewById(id)).setImageDrawable(result); } @Override protected void onPreExecute() { // TODO Auto-generated method stub super.onPreExecute(); } @Override protected void onProgressUpdate(Integer... values) { // TODO Auto-generated method stub super.onProgressUpdate(values); } }
这里打印的log
5.ExecutorServie线程池
通过Executors的静态方法来创建,一般有三种:
1.单线程 :Executors.newSingleThreadExecutor();
2.固定数量线程 :Executors.newFixedThreadPool();
3.动态线程 :Executors.newCachedThreadPool();
这里我们用固定5个线程来应用,使用方法是创建ExecutorService对象,然后执行submit(r)可以发起一个Runnable对象。用线程池来管理的好处是,可以保证系统稳定运行,适用与有大量线程,高工作量的情景下使用,假如要展示1000张图片如果创建1000个线程去加载,保证系统会死掉。用线程池就可以避免这个问题,可以用5个线程轮流执行,5个一组,执行完的线程不直接回收而是等待下次执行,这样对系统的开销就可以减小不少。
private void loadImagesByExecutors(final String url,final int id){ service.submit(new Runnable(){ @Override public void run() { // TODO Auto-generated method stub Log.e("当前线程:", ""+Thread.currentThread().getName()); try { final Drawable drawable = Drawable.createFromStream(new URL(url).openStream(), "image.gif"); mainHandler.post(new Runnable(){ @Override public void run() {//这将在主线程运行 // TODO Auto-generated method stub ((ImageView)MainActivity.this.findViewById(id)).setImageDrawable(drawable); } }); } catch (MalformedURLException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }); }
Log:
其实可能没有说清楚,第一种不算多线程。
1.loadImagesByHandler()是通过Handler.post()方法,构建两个Handler进行通信。
2.loadImagesByThread(),这个是直接new Thread()发起线程,在主线程的handler处理消息
3.loadImageByAsyncTask(),这个用的是异步任务,所有实现在它的内部结构里,可以在里头操作Ui.
4.loadImagesByExecutors()用的是线程池,使得线程可控,保证稳定运行。
其实常用的就是后三种,第二个用法灵活,简单,但不适宜大数量任务;第三个一般适用于单个任务,一次性任务;第四个一般用于大数量,高密度执行的使用情景,比如批量加载图片,批量下载文件等。
看一眼图吧:
全部源码:
1 package com.bvin.exec; 2 3 import java.io.IOException; 4 import java.net.MalformedURLException; 5 import java.net.URL; 6 import java.util.concurrent.ExecutorService; 7 import java.util.concurrent.Executors; 8 9 import android.app.Activity; 10 import android.graphics.drawable.Drawable; 11 import android.os.AsyncTask; 12 import android.os.Bundle; 13 import android.os.Handler; 14 import android.os.HandlerThread; 15 import android.os.Message; 16 import android.util.Log; 17 import android.view.View; 18 import android.widget.Button; 19 import android.widget.ImageView; 20 21 public class MainActivity extends Activity { 22 /** Called when the activity is first created. */ 23 24 private Handler handler ; 25 private Button bt; 26 private Handler mainHandler = new Handler(){ 27 28 @Override 29 public void handleMessage(Message msg) { 30 // TODO Auto-generated method stub 31 super.handleMessage(msg); 32 if(msg.what == 2012){ 33 //只要在主线程就可以处理ui 34 ((ImageView)MainActivity.this.findViewById(msg.arg1)).setImageDrawable((Drawable)msg.obj); 35 } 36 } 37 38 39 }; 40 41 private ExecutorService service = Executors.newFixedThreadPool(5); 42 43 @Override 44 public void onCreate(Bundle savedInstanceState) { 45 super.onCreate(savedInstanceState); 46 setContentView(R.layout.main); 47 initViews(); 48 HandlerThread ht = new HandlerThread("down image thread"); 49 ht.start(); 50 handler = new Handler(ht.getLooper()){//如果有了looper那么这个handler就不可以处理ui了 51 52 @Override 53 public void handleMessage(Message msg) { 54 // TODO Auto-generated method stub 55 super.handleMessage(msg); 56 57 58 } 59 60 }; 61 62 } 63 64 private void initViews(){ 65 66 bt = (Button)findViewById(R.id.bt); 67 bt.setOnClickListener(new View.OnClickListener() { 68 69 @Override 70 public void onClick(View v) { 71 // TODO Auto-generated method stub 72 loadImagesByExecutors("http://news.baidu.com/z/resource/r/image/2012-11-23/23c1625aca99f02c50d8e510383a34e7.jpg",R.id.iv1); 73 loadImagesByExecutors("http://news.baidu.com/z/resource/r/image/2012-11-23/c4698d97ef6d10722c8e917733c7beb3.jpg",R.id.iv2); 74 loadImagesByExecutors("http://news.baidu.com/z/resource/r/image/2012-11-23/f332ffe433be2a3112be15f78bff5a40.jpg",R.id.iv3); 75 loadImagesByExecutors("http://news.baidu.com/z/resource/r/image/2012-11-23/6ff8a9c647a1e80bc602eeda48865d4c.jpg",R.id.iv4); 76 loadImagesByExecutors("http://news.baidu.com/z/resource/r/image/2012-11-23/f104d069f7443dca52a878d779392874.jpg",R.id.iv5); 77 } 78 }); 79 } 80 81 private void loadImagesByHandler(final String url,final int id){//通过拥有looper的handler.post(runnable),新建线程 82 83 84 handler.post(new Runnable(){//如果handler没有Looper那么它就不能构建新线程了 85 86 @Override 87 public void run() { 88 // TODO Auto-generated method stub 89 Log.e("当前线程:", ""+Thread.currentThread().getName()); 90 Drawable drawable = null; 91 try { 92 drawable = Drawable.createFromStream(new URL(url).openStream(), "image.gif"); 93 } catch (MalformedURLException e) { 94 // TODO Auto-generated catch block 95 e.printStackTrace(); 96 } catch (IOException e) { 97 // TODO Auto-generated catch block 98 e.printStackTrace(); 99 } 100 //SystemClock.sleep(2000); 101 //((ImageView)MainActivity.this.findViewById(id)).setImageDrawable(drawable); 102 Message msg = mainHandler.obtainMessage(); 103 msg.what = 2012; 104 msg.arg1 = id; 105 msg.obj = drawable; 106 msg.sendToTarget(); 107 } 108 109 }); 110 111 112 } 113 114 private void loadImagesByThread(final String url,final int id){//通过Thread来new 出多个线程 115 116 new Thread(new Runnable(){ 117 118 @Override 119 public void run() { 120 // TODO Auto-generated method stub 121 Log.e("当前线程:", ""+Thread.currentThread().getName()); 122 Drawable drawable = null; 123 try { 124 drawable = Drawable.createFromStream(new URL(url).openStream(), "image.gif"); 125 } catch (MalformedURLException e) { 126 // TODO Auto-generated catch block 127 e.printStackTrace(); 128 } catch (IOException e) { 129 // TODO Auto-generated catch block 130 e.printStackTrace(); 131 } 132 Message msg = mainHandler.obtainMessage(); 133 msg.what = 2012; 134 msg.arg1 = id; 135 msg.obj = drawable; 136 msg.sendToTarget(); 137 138 } 139 140 }).start(); 141 } 142 143 private void loadImageByAsyncTask(final String url,final int id){//构建异步任务,这样就不用handler来处理消息了 144 DownloadTask task = new DownloadTask(); 145 task.execute(""+id,url);//AsyncTask不可重复执行 146 } 147 148 private void loadImagesByExecutors(final String url,final int id){ 149 service.submit(new Runnable(){ 150 151 @Override 152 public void run() { 153 // TODO Auto-generated method stub 154 Log.e("当前线程:", ""+Thread.currentThread().getName()); 155 156 try { 157 final Drawable drawable = Drawable.createFromStream(new URL(url).openStream(), "image.gif"); 158 mainHandler.post(new Runnable(){ 159 160 @Override 161 public void run() {//这将在主线程运行 162 // TODO Auto-generated method stub 163 ((ImageView)MainActivity.this.findViewById(id)).setImageDrawable(drawable); 164 } 165 }); 166 167 } catch (MalformedURLException e) { 168 // TODO Auto-generated catch block 169 e.printStackTrace(); 170 } catch (IOException e) { 171 // TODO Auto-generated catch block 172 e.printStackTrace(); 173 } 174 175 } 176 177 }); 178 179 } 180 181 class DownloadTask extends AsyncTask<String,Integer,Drawable>{ 182 183 int id; 184 @Override 185 protected Drawable doInBackground(String... params) {//params保存url和控件id两个数据 186 // TODO Auto-generated method stub 187 Log.e("当前线程:", ""+Thread.currentThread().getName()); 188 Drawable drawable = null; 189 this.id = Integer.parseInt(params[0]); 190 try { 191 drawable = Drawable.createFromStream(new URL(params[1]).openStream(), "image.gif"); 192 } catch (MalformedURLException e) { 193 // TODO Auto-generated catch block 194 e.printStackTrace(); 195 } catch (IOException e) { 196 // TODO Auto-generated catch block 197 e.printStackTrace(); 198 } 199 200 return drawable; 201 } 202 203 @Override 204 protected void onPostExecute(Drawable result) { 205 // TODO Auto-generated method stub 206 super.onPostExecute(result); 207 ((ImageView)MainActivity.this.findViewById(id)).setImageDrawable(result); 208 } 209 210 @Override 211 protected void onPreExecute() { 212 // TODO Auto-generated method stub 213 super.onPreExecute(); 214 } 215 216 @Override 217 protected void onProgressUpdate(Integer... values) { 218 // TODO Auto-generated method stub 219 super.onProgressUpdate(values); 220 } 221 222 223 } 224 }
http://www.cnblogs.com/bvin/archive/2012/11/23/2784934.html