Thread thread0 = new Thread(new Runnable() {
        @Override
        public void run() {
            //耗时操作
    thread0.start();
     MyThread2 thread1 = new MyThread2("name1");
     thread1.start();  
自定义Thread
     private class MyThread2 extends Thread {
         public MyThread2(String name) {
             super(name);
         @Override
         public void run() {
             super.run();
####（2）实现Runnable/自定义Runnable
    Thread thread1 = new Thread(this);
    thread1.start();
而this，是指在Act类后，添加 implements Runnable,然后act类中重写 run方法：
  @Override
  public void run() {
    Thread thread1 = new Thread(new MyRunnable());
    thread1.start();
这是自定义的Runnable 类
        private class MyRunnable implements Runnable {
            @Override
            public void run() {
###（4）线程的构造解读：
总共有8个构造重载，05--08可以理解成一个重载，使用方式见代码，
####注：当自定义Thread(Runnable run1)类中还有重写的run方法，执行顺序是；先执行参数run1，再执行重写的run方法
     * 01 new 自定义无参thread,需在该线程中重写run方法。
    public MyThread() {
     * 02 给自定义的thread线程起一个名称
     * @param name
    public MyThread(String name) {
        super(name);
     * 03 implement Runnable形式,该Runnable可以自定义
     * @param target
    public MyThread2(Runnable target) {
        super(target);
     * 04 有名称的线程，使用Runnable形式
    public MyThread2(Runnable target, String name) {
        super(target, name);
     * @param group
     * @param target
    public MyThread3(ThreadGroup group, Runnable target) {
        super(group, target);
     * @param group
     * @param name
    public MyThread3(ThreadGroup group, String name) {
        super(group, name);
     * @param group
     * @param target
     * @param name
    public MyThread3(ThreadGroup group, Runnable target, String name) {
        super(group, target, name);
     * @param group     指定当前线程的线程组
     * @param target    需要指定，或者 在自定义线程中重写run
     * @param name      线程的名称，不指定自动生成
     * @param stackSize 预期堆栈大小，不指定默认为0
    public MyThread3(ThreadGroup group, Runnable target, String name, long stackSize) {
        super(group, target, name, stackSize);
##二HandlerThread介绍：
HandlerThread特点:
1本质是线程，继承Thread
2HandlerThread内部有自己的Looper对象,可以在当前线程中处理分发消息
3通过获取HandlerThread的looper对象传递给Handler对象，可以在handleMessage方法中执行异步任务
1.开发中如果多次使用类似new Thread(){}.start()这种方式开启子线程，会创建多个匿名线程，使得程序运行起来越来越慢，
而HandlerThread自带Looper使他可以通过消息机制来多次重复使用当前线程，节省开支。
2.Handler类内部的Looper默认绑定的是UI线程的消息队列，对于非UI线程如果需要使用消息机制，
自己去创建Looper较繁琐，由于HandlerThread内部已经自动创建了Looper，直接使用HandlerThread更方便
###常见用法：
用法1：Handler(Looper looper,Callback callback)执行异步
用法2：Handler(Looper looper）{handleMessage}执行异步
用法3：handler.post(runnable)执行异步
用法4:验证handler的post和重写handleMessage的执行顺序
##三 IntentService 异步介绍：
它本质是一种特殊的Service,继承自Service并且本身就是一个抽象类
它可以用于在后台执行耗时的异步任务，当任务完成后会自动停止
它拥有较高的优先级，不易被系统杀死（继承自Service的缘故），因此比较适合执行一些高优先级的异步任务
它内部通过HandlerThread和Handler实现异步操作
创建IntentService时，只需实现onHandleIntent和 空构造方法这两步骤即可，onHandleIntent为异步方法，可以执行耗时操作
###使用步骤：
1:自定义的ItnentService重写onHandleIntent方法
2：在Manifest.xml注册自定义的ItnentService
3: startService(intent);启动服务
###常见用法：
方式1：自定义回调UI
方式2：LocalBroadcastManager触发广播回调UI
方式3：act触发广播回调UI
##四 线程池介绍：
###1Executors类详解：
使用说明，其下有6类线程创建方式，还有其他三个辅助方法
=========================================6类线程创建=======================================
public static ExecutorService newSingleThreadExecutor()
public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory)
用于创建只有一个线程的线程池
hreadFactory，自定义创建线程时的行为
public static ExecutorService newCachedThreadPool()
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory)
用于创建线程数数目可以随着实际情况自动调节的线程池
当线程池有很多任务需要处理时，会不断地创建新线程，当任务处理完毕之后，如果某个线程空闲时间大于60s，则该线程将会被销毁。
因为这种线程池能够自动调节线程数量，所以比较适合执行大量的短期的小任务
public static ScheduledExecutorService newSingleThreadScheduledExecutor()
public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory)
用于创建只有一个线程的线程池，并且该线程定时周期性地执行给定的任务
说明：线程在周期性地执行任务时如果遇到Exception，则以后将不再周期性地执行任务
public static ExecutorService newFixedThreadPool(int nThreads)
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory)
用于创建一个最大线程数的固定的线程池，多余任务存储在队列中，等待线程池某一个线程完成任务，后续任务补充进去继续使用，总之，保持最大线程数不变
threadFactory是线程工厂类，主要用于自定义线程池中创建新线程时的行为
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)
用于创建一个线程池，线程池中得线程能够周期性地执行给定的任务
public static ExecutorService newWorkStealingPool(int parallelism)
public static ExecutorService newWorkStealingPool()
用于创建ForkJoin框架中用到的ForkJoinPool线程池，参数parallelism用于指定并行数，默认使用当前机器可用的CPU个数作为并行数。
=============================================其他方法==============================================
public static ExecutorService unconfigurableExecutorService(ExecutorService executor)
用于包装现有的线程池，包装之后的线程池不能修改，相当于final
public static ScheduledExecutorService unconfigurableScheduledExecutorService(ScheduledExecutorService executor)
用于包装可以周期性执行任务的线程池，包装之后的线程池不能修改，相当于final
public static ThreadFactory defaultThreadFactory()
返回默认的工厂方法类，默认的工厂方法为线程池中新创建的线程命名为：pool-[虚拟机中线程池编号]-thread-[线程编号
public static ThreadFactory privilegedThreadFactory()
返回用于创建新线程的线程工厂，这些新线程与当前线程具有相同的权限。此工厂创建具有与 defaultThreadFactory() 相同设置的线程，
新线程的 AccessControlContext 和 contextClassLoader 的其他设置与调用此 privilegedThreadFactory 方法的线程相同。可以在 AccessController.doPrivileged(java.security.PrivilegedAction) 操作中创建一个新 privilegedThreadFactory，设置当前线程的访问控制上下文，以便创建具有该操作中保持的所选权限的线程。
注意，虽然运行在此类线程中的任务具有与当前线程相同的访问控制和类加载器，但是它们无需具有相同的 ThreadLocal
或 InheritableThreadLocal 值。如有必要，使用 ThreadPoolExecutor.beforeExecute(java.lang.Thread, java.lang.Runnable)
在 ThreadPoolExecutor 子类中运行任何任务前，可以设置或重置线程局部变量的特定值。
另外，如果必须初始化 worker 线程，以具有与某些其他指定线程相同的 InheritableThreadLocal 设置，
则可以在线程等待和服务创建请求的环境中创建自定义的 ThreadFactory，而不是继承其值。
    public static Callable <Object> callable(Runnable task) 
运行给定的任务并返回 null
    public static <T> Callable<T> callable(Runnable task,T result) 
运行给定的任务并返回给定的结果。这在把需要 Callable 的方法应用到其他无结果的操作时很有用
    public static Callable<Object> callable(PrivilegedAction<?> action) 
运行给定特权的操作并返回其结果