译文 | Android 开发中利用异步来优化运行速度和性能

String[] urls = …    
for (final String url : urls) {        
new Thread(new Runnable() {            
public void run() {                
// 调用API、下载数据或图片             
}         
}).start();

   }

  public class CameraHandlerThread extends HandlerThread            
 implements Camera.PictureCallback, Camera.PreviewCallback {        
private static String TAG = "CameraHandlerThread";       
private static final int WHAT_PROCESS_IMAGE = 0;         
Handler mHandler = null;         
WeakReference<camerapreviewfragment> ref = null;       
 private PictureUploadHandlerThread mPictureUploadThread;        
private boolean mBurst = false;        
private int mCounter = 1;          
CameraHandlerThread(CameraPreviewFragment cameraPreview) {            
super(TAG);             
start();             
mHandler = new Handler(getLooper(), new Handler.Callback() {               
 @Override                 
public boolean handleMessage(Message msg) {                    
if (msg.what == WHAT_PROCESS_IMAGE) {                        
// 业务逻辑                     
}                   
 return true;                
 }            
 });            
 ref = new WeakReference<>(cameraPreview);         
}       
 ...        
@Override         
public void onPreviewFrame(byte[] data, Camera camera) {            
if (mBurst) {                 
CameraPreviewFragment f = ref.get();                
if (f != null) {                     
mHandler.obtainMessage(WHAT_PROCESS_IMAGE, data)                    
.sendToTarget();                    
try {                         
sleep(100);                     
} catch (InterruptedException e) {                         
e.printStackTrace();                     
}                    
if (f.isAdded()) {                         
f.readyForPicture();                    
 }                 
}                
if (mCounter++ == 10) {                     
mBurst = false;                     
mCounter = 1;     
   }             
}        
 }     
}

 public class BitmapThreadPool {        
private static BitmapThreadPool mInstance;       
private ThreadPoolExecutor mThreadPoolExec;        
private static int MAX_POOL_SIZE;        
private static final int KEEP_ALIVE = 10;         
BlockingQueue<runnable> workQueue = new LinkedBlockingQueue<>();        
public static synchronized void post(Runnable runnable) {            
if (mInstance == null) {                 
mInstance = new BitmapThreadPool();            
 }            
 mInstance.mThreadPoolExec.execute(runnable);        
 }       
 private BitmapThreadPool() {           
 int coreNum = Runtime.getRuntime().availableProcessors();             
MAX_POOL_SIZE = coreNum * 2;             
mThreadPoolExec = new ThreadPoolExecutor(                     
coreNum,                     
MAX_POOL_SIZE,                    
 KEEP_ALIVE,                     
TimeUnit.SECONDS,                     
workQueue);        
 }        
public static void finish() {             
mInstance.mThreadPoolExec.shutdown()
;         }    
 }

mHandler = new Handler(getLooper(), new Handler.Callback() {        
@Override         
public boolean handleMessage(Message msg) {           
 if (msg.what == WHAT_PROCESS_IMAGE) {                 
BitmapThreadPool.post(new Runnable() {                    
@Override                    
 public void run() {                       
 // 做你想做的任何事情                     
}                
 });            
 }            
return true; 
}     
});