Android 总结2-线程

//创建HandlerThread实例
HandlerThread mHandlerThread = new HandlerThread("handler_thread");
//开始运行线程
mHandlerThread.start();
//获取HandlerThread线程中的Looper实例
Looper loop = mHandlerThread.getLooper();
//创建Handler与该线程绑定。
mSubThreadHandler = new Handler(loop){
public void handleMessage(Message msg) {}
}

new Thread(){   
       @Override    
       public void run() {        
           Looper.prepare();  //获取当前线程的Looper，并prepare();
           Handler handler = new Handler() {           
               @Override          
               public void handleMessage(Message msg) {                
                   Toast.makeText(MainActivity.this, "handler msg", Toast.LENGTH_SHORT).show();            
               }        
           };        
           handler.sendEmptyMessage(0);   
           Looper.loop();  //looper开始处理消息。
       }
}.start();

TestThread testThread = new TestThread();
testThread.start();
class TestThread extends Thread {
    @Override
    public void run() {
        super.run();
    }
}

TestRunnable run = new TestRunnable();
Thread tt = new Thread(run);
tt.start();
class TestRunnable implements Runnable{
    @Override
    public void run() {
    }
}

AsyncTestThread asyncTestThread = new AsyncTestThread();
asyncTestThread.execute();// 串行
asyncTestThread.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"");//并行
class AsyncTestThread extends AsyncTask<String, String, String> {
       // 1作用：执行 线程任务前的操作
       @Override
       protected void onPreExecute() {
           Log.e("jfson", "pre 0");
           super.onPreExecute();
       }
       // 2作用：接收输入参数、执行任务中的耗时操作、返回 线程任务执行的结果
       @Override
       protected String doInBackground(String... strings) {
           for (int i = 0; i < 100; i++) {
               try {
                   Thread.sleep(100);
                   //进度条每次更新10%,执行中创建新线程处理onProgressUpdate()
                   publishProgress(String.valueOf(i));
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
           Log.e("jfson", "doInBackground finish :");
           return "下载完成!";
       }
       // 3作用：在主线程 显示线程任务执行的进度
       @Override
       protected void onProgressUpdate(String... values) {
           Log.e("jfson", "onProgressUpdate :" + values[0]);
           super.onProgressUpdate(values);
       }
       // 4作用：接收线程任务执行结果..UI线程
       @Override
       protected void onPostExecute(String s) {
           Log.e("jfson", "onPostExecute :" + s);
           super.onPostExecute(s);
       }
       // 5任务执行完成、UI线程
       @Override
       protected void onCancelled() {
           Log.e("jfson", "onCancelled :");
           super.onCancelled();
       }
  }

 public void execute(Runnable task) {    
        synchronized (taskQueue) {    
            taskQueue.add(task);    
            taskQueue.notifyAll();  //当调用execute()方法的时候，执行notiry()，只会唤醒线程池中的一个线程，注意与notoryAll()的区别    
        }    
    }  
    
/*内部类 即一个线程池对象*/  
    private class WorkThread extends Thread{  
        //该工作线程是否有效，用来接收该工作线程  
        private boolean isRunnable=true;  
        /*  
         * 关键所在，如果任务队列不空，则求出任务执行，若任务队列为空，则等待  
        */  
        @Override  
        public void run() {  
            //接收队列当中的任务对象 任务对象Runnable类型  
            Runnable r=null;  
            while(isRunnable){  
                //队列同步机制  
                synchronized(taskQueue){  
                    while(isRunnable && taskQueue.isEmpty()){//队列为空  
                        try {  
                            taskQueue.wait(20);  
                        } catch (InterruptedException e) {  
                            // TODO Auto-generated catch block  
                            e.printStackTrace();  
                        }  
                    }  
                    if(!taskQueue.isEmpty()){  
                        try {  
                            r=taskQueue.take();// 获取并移除第一个元素  
                        } catch (InterruptedException e) {  
                            // TODO Auto-generated catch block  
                            e.printStackTrace();  
                        }  
                    }  
                    if(r!=null){  
                        r.run();//执行任务  
                    }  
                    executeTaskNumber++;  
                    r=null;  
                }  
            }  
        }  
        public void stopWorker(){  
            isRunnable=false;  
        }  
    }

public static String get(IRequest request) {
        InputStream inputStream = null;
        HttpURLConnection httpURLConnection = null;
        try {
            URL url = new URL(buildGetUrl(request.getBaseUrl(), request.getParam(), request.getEncrypt()));
            openUrlConnection(url,httpURLConnection);
            normalSetting(httpURLConnection, Method.GET, request.getHeaders());
            if (httpURLConnection == null) {
                return null;
            }
            int responseCode = httpURLConnection.getResponseCode();
            if (responseCode == HttpURLConnection.HTTP_OK) {
                inputStream = httpURLConnection.getInputStream();
                String contentEncoding = httpURLConnection.getContentEncoding();
                InputStream stream = null;
                try {
                    stream = wrapStream(contentEncoding, inputStream);
                    String data = convertStreamToString(stream);
                    return data;
                } catch (IOException e) {
                    return "";
                } finally {
                    closeQuietly(stream);
                }
            }
            return null;
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "";
    }