线程的正确使用方式

http://android.jobbole.com/82440/

进程优先级:Active->Visible->Service->Backgroud->Empty

线程分类--
1.default group UI线程属于这类
2.backgroud group 工作线程属于这一类

Thread,AsynTask:适合单个任务的场景。
HandlerThread:适合串行处理多任务的场景,只有一个线程，所产生的线程会一直存活。（多张图片上传的时候可以使用）

 public class LoadingActivity extends Activity{
 private HandlerThread handlerThread;
 private Handler mHandler;
 private TextView tv;
 
 
@Override
 protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.activity_loading);
 tv = (TextView)findViewById(R.id.tv);
 init();
 }
 private void init(){
 //自带Loop
 handlerThread = new HandlerThread("Main");
 handlerThread.setPriority(1);
 handlerThread.start();
 mHandler = new Handler(handlerThread.getLooper(), new Handler.Callback() {
 @Override
 public boolean handleMessage(Message msg) {
 tv.setText("你好啊");
 return true;
 }
 });
 mHandler.post(new Runnable() {
 @Override
 public void run() {
 System.out.println("handler_post_cur_id="+Thread.currentThread().getId());
 mHandler.sendEmptyMessage(1);
 }
 });
 }
 @Override
 protected void onDestroy() {
 super.onDestroy();
 //需要手动关闭，因为Loop是无限循环的
 handlerThread.quit();
 }
 }
 

ThreadPoolExecutor:适合并行多任务的场景。http://www.jianshu.com/p/3da543063b8c
官方定义的四种线程池,都是通过Executors的工厂方法来实现
1.FixedThreadPool 一种数量固定的线程池，且任务队列没有大小限制。只有核心线程，没有超时限制。
2.CachedThreadPool 无界线程池，可以自行进行线程回收。只有非核心线程，最大线程数为Integer.MAX_VALUE。
3.SingleThreadExecutor 只有一个核心线程，所有任务都在同一线程中按序执行。
4.ScheduledThreadPool 核心线程数量固定，非核心线程没有限制。非核心线程空闲会被回收。

 public class LoadingActivity extends Activity{
 private final int CORE_POOL_SIZE = 1;//核心线程数
 private final int MAX_POOL_SIZE = 3;//最大线程数,线程池中的线程数不会超过最大线程数
 private final int BLOCK_SIZE = 2;//阻塞队列大小,缓存队列
 private final long KEEP_ALIVE_TIME = 2;//空闲线程超时时间,超时会被回收
 private ThreadPoolExecutor executorPool;
 
 
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_loading);

    init();
}

private void init(){
    /**
     * TimeUnit.SECONDS keepAliveTime时间单位，这边设置为秒
     * Executors.defaultThreadFactory()线程工厂，为线程池提供创建线程的方法
     * new ThreadPoolExecutor.AbortPolicy() 拒绝任务的处理策略
     *  1、ThreadPoolExecutor.AbortPolicy()   直接抛出异常RejectedExecutionException
        2、ThreadPoolExecutor.CallerRunsPolicy()    直接调用run方法并且阻塞执行
        3、ThreadPoolExecutor.DiscardPolicy()   直接丢弃后来的任务
        4、ThreadPoolExecutor.DiscardOldestPolicy()  丢弃在队列中队首的任务
     */
    executorPool = new ThreadPoolExecutor(CORE_POOL_SIZE,MAX_POOL_SIZE,KEEP_ALIVE_TIME, TimeUnit.SECONDS, new ArrayBlockingQueue(BLOCK_SIZE),Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
    executorPool.allowCoreThreadTimeOut(true);//设置true会超时退出,默认不退出
    executorPool.execute(new WorkerThread());
}

public class WorkerThread implements Runnable {

    @Override
    public void run() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
 
 
}
 

IntentService:内部也是用HandlerThread的方式，适合需要在工作线程中处理UI无关任务的场景。可以做耗时操作的Service，单独处理串行任务。记得在manifest中需要配置，跟The same as Service.

 public class ConsumeService extends IntentService{
 private Handler mHandler = new Handler(){
 @Override
 public void handleMessage(Message msg) {
 super.handleMessage(msg);
 }
 };
 /**
 * Creates an IntentService. Invoked by your subclass's constructor.
 *
 * @param name Used to name the worker thread, important only for debugging.
 */
 public ConsumeService(String name) {
 super(name);
 }
 
 
@Override
public void onCreate() {
    System.out.println("onCreate");
    super.onCreate();
}

@Override
public void onStart(Intent intent, int startId) {
    System.out.println("onStart"+startId);
    super.onStart(intent, startId);
}

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
    System.out.println("onStartCommand");
    return super.onStartCommand(intent, flags, startId);
}

@Override
protected void onHandleIntent(Intent intent) {
    //Intent是从Activity发过来的，携带识别参数
    try {
        mHandler.sendEmptyMessageAtTime(1,1000);
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}
 
 
}