Android基础Thread7.三种阻塞型消息循环

3种阻塞型消息循环

1、LooperThread

class LooperThread extends Thread{
private Handler mHandler;
public static finalint MSG_1 = 1;
public static finalint MSG_2 = 2;
public void run(){
        Looper.prepare();
        Log.v("djh","run()");
        mHandler = new Handler() {
public void handleMessage(Message msg){
            switch (msg.what) {
            case MSG_1:
                                Log.v("djh", "1");
            break;
            case MSG_2:
                                Log.v("djh", "2");
            break;
            
            default:
            break;
                }
            }
        };
        Looper.loop();
    }

public static void sendMsg(Handler handler, int what, Object object){
        Message msg = new Message();
        msg.what = what;
        msg.obj = object;
handler.sendMessage(msg);
    }

public Handler getHandler(){
        Log.v("djh", "getHandler()");
        return mHandler;
}
使用的时候注意getHandler的时机 ， 然后一直发送消息 给Thread处理就行了。
 mLooperThread = new LooperThread();
 mLooperThread.start();
        findViewById(R.id.btn_test_1).setOnClickListener(new OnClickListener() {

@Override
publicvoidonClick(View v){
        mQueue.add(new BlockingQueueTask("1"));
         mHandler.sendEmptyMessage(1);
    }
});

2、BlockingQueue 消息循环

public class BlockingQueueThread extends Thread{
private BlockingQueue<BlockingQueueTask> mQueue;
public BlockingQueueThread(BlockingQueue<BlockingQueueTask> queue){
        mQueue = queue;
    }
@Override
public void run(){
while (true) {
try {
                Log.v("djh", "while (true)" );
                BlockingQueueTask task = mQueue.take();
                Log.v("djh", "id " + task.id);
            } catch (InterruptedException e) {
// TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

}

public class BlockingQueueTask{
public String id ;

public BlockingQueueTask(String id){
this.id = id;
    }

}
```c
使用的时候用再 mQueue 队列中一直加入元素就行了，因为BlockingQueue 是阻塞的，这边随便建立了个Task。
```c
mQueue = new ArrayBlockingQueue<BlockingQueueTask>(1000);
    mBlockingThread = new BlockingQueueThread(mQueue);
    mBlockingThread.start();

    findViewById(R.id.btn_test_1).setOnClickListener(new OnClickListener() {

@Override
public void onClick(View v){
            mQueue.add(new BlockingQueueTask("1"));

        }
    });

    findViewById(R.id.btn_test_2).setOnClickListener(new OnClickListener() {

@Override
public void onClick(View v){
            mQueue.add(new BlockingQueueTask("2"));
        }
    });

3、LinkedList 消息循环

public class DownloadTaskManagerThread implements Runnable{  

private DownloadTaskManager downloadTaskManager;  
// 创建一个可重用固定线程数的线程池  
private ExecutorService pool;  
// 线程池大小  
privatefinalint POOL_SIZE = 5;  
// 轮询时间  
privatefinalint SLEEP_TIME = 1000;  
// 是否停止  
privateboolean isStop = false;  

public DownloadTaskManagerThread(){  
        downloadTaskManager = DownloadTaskManager.getInstance();  
        pool = Executors.newFixedThreadPool(POOL_SIZE);  

    }  

@Override
public void run(){  
// TODO Auto-generated method stub  
while (!isStop) {  
            DownloadTask downloadTask = downloadTaskManager.getDownloadTask();  
if (downloadTask != null) {  
                pool.execute(downloadTask);  
            } else {  //如果当前未有downloadTask在任务队列中  
try {  
// 查询任务完成失败的,重新加载任务队列  
// 轮询,  
                    Thread.sleep(SLEEP_TIME);  
                } catch (InterruptedException e) {  
// TODO Auto-generated catch block  
                    e.printStackTrace();  
                }  
            }  

        }  
if (isStop) {  
            pool.shutdown();  
        }  

    }  

/** 
     * @param isStop 
     *            the isStop to set 
     */
public void setStop(boolean isStop){  
this.isStop = isStop;  
    }  
}

这种比较low点 但是他的task 比较丰富

public class DownloadTaskManager{  
private static final String TAG="DownloadTaskManager";  
// UI请求队列  
private LinkedList<DownloadTask> downloadTasks;  
// 任务不能重复  
private Set<String> taskIdSet;  

private static DownloadTaskManager downloadTaskMananger;  

private DownloadTaskManager(){  

        downloadTasks = new LinkedList<DownloadTask>();  
        taskIdSet = new HashSet<String>();  

    }  

public static synchronized DownloadTaskManager getInstance(){  
if (downloadTaskMananger == null) {  
            downloadTaskMananger = new DownloadTaskManager();  
        }  
return downloadTaskMananger;  
    }  

//1.先执行  
public void addDownloadTask(DownloadTask downloadTask){  
synchronized (downloadTasks) {  
if (!isTaskRepeat(downloadTask.getFileId()+"")) {  
// 增加下载任务  
                downloadTasks.addLast(downloadTask);   
            }  
        }  

    }  
public boolean isTaskRepeat(String fileId){  
synchronized (taskIdSet) {  
if (taskIdSet.contains(fileId)) {  
return true;  
            } else {  
                System.out.println("下载管理器增加下载任务："+ fileId);  
                taskIdSet.add(fileId);  
return false;  
            }  
        }  
    }  

public DownloadTask getDownloadTask(){  
synchronized (downloadTasks) {  
if (downloadTasks.size() > 0) {  
                System.out.println("下载管理器增加下载任务："+"取出任务");  
                DownloadTask downloadTask = downloadTasks.removeFirst();  
return downloadTask;  
            }  
        }  
returnnull;  
    }  
}  

public class DownloadTask implements Runnable{
private String mId;

public DownloadTask(String string){
// TODO Auto-generated constructor stub
        mId = string;
    }

public String getFileId(){
return mId;
    }

@Override
public void run(){
// TODO Auto-generated method stub
        Log.v("djh", "mId " +mId);
    }

}
可以管理，使用如下
DownloadTaskManager.getInstance();
//       2.new一个线程池，并启动
         DownloadTaskManagerThread downloadTaskManagerThread = new
         DownloadTaskManagerThread();
new Thread(downloadTaskManagerThread).start();

         TaskThread mThread = new TaskThread();
         mThread.start();
// 3.请求下载
         String[] items = new String[] { "djh1", "djh2", "djh3", "djh4",
"djh5", "djh6", "djh7", "djh1", "djh2" };

for (int i = 0; i < items.length; i++) {
         DownloadTaskManager downloadTaskMananger =
         DownloadTaskManager.getInstance();
         downloadTaskMananger.addDownloadTask(new DownloadTask(items[i]));
try {
         Thread.sleep(20);
         } catch (InterruptedException e) {
         e.printStackTrace();
         }
         }