android 多线程学习2：线程的创建与方法分析

android 多线程学习1：一些基础
android 多线程学习2：线程的创建与方法分析
android 多线程学习3：synchronized与volatile与线程安全对象
android 多线程学习4：线程池ThreadPoolExecutor
android 多线程学习5：AsyncTask
android 多线程学习6：HandlerThread
android 多线程学习7：Handler消息处理机制

一、创建线程

1. 使用或继承Thread

        Thread threadA = new Thread() {
            @Override
            public void run() {
                super.run();
                //do something
            }
        };
        threadA.start();

2. 通过Runable接口

        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                //do something
            }
        });
        threadA.start();

3. 通过ThreadFactory

        ThreadFactory threadFactory = new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                return new Thread(r,"Thread 1");
            }
        };
        Thread threadA = threadFactory.newThread(new Runnable() {
            @Override
            public void run() {
                //do something
            }
        });
        threadA.start();

4. 通过Callable

        FutureTask futureTask = new FutureTask<>(new Callable() {
            @Override
            public String call() throws Exception {
                //do something
                return "ok";
            }
        });
        Thread threadA = new Thread(futureTask);
        threadA.start();

5. 使用线程池Executors

        Executors.newFixedThreadPool(1)
                .submit(new Runnable() {
                    @Override
                    public void run() {
                        //do something
                    }
                });

Executors

6. Android中的HandlerThread

        HandlerThread handlerThread = new HandlerThread("HandlerThread");
        handlerThread.start();

7. Android中的AsyncTask

        AsyncTask asyncTask = new AsyncTask(){

            @Override
            protected void onPreExecute() {
                super.onPreExecute();
            }

            @Override
            protected Object doInBackground(String... strings) {
                return null;
            }

            @Override
            protected void onPostExecute(Object o) {
                super.onPostExecute(o);
            }
        };
        asyncTask.execute();

二、线程的状态

1. 新建(NEW)：实现Runnable接口和继承Thread可以得到一个线程类，new一个实例出来，线程就进入了初始状态。

2. 可运行(RUNNABLE)：线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu 的使用权 。

   • 调用线程的start()方法，此线程进入可运行状态。
   • 可运行状态只是说你资格运行，调度程序没有挑选到你，你就永远是可运行状态。
   • 当前线程sleep()方法结束，其他线程join()结束，等待用户输入完毕，某个线程拿到对象锁，这些线程也将进入可运行状态。
   • 当前线程时间片用完了，调用当前线程的yield()方法，当前线程进入可运行状态。
   • 锁池里的线程拿到对象锁后，进入可运行状态。

3. 运行(RUNNING)：可运行状态(runnable)的线程获得了cpu 时间片（timeslice） ，执行程序代码。

   • 线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一一种方式。

4. 阻塞(BLOCKED)：阻塞状态是指线程因为某种原因放弃了cpu 使用权，也即让出了cpu timeslice，暂时停止运行。直到线程进入可运行(runnable)状态，才有机会再次获得cpu timeslice 转到运行(running)状态。

   阻塞的情况分三种：
   * 等待阻塞：运行(running)的线程执行o.wait()方法，JVM会把该线程放入等待队列(waitting queue)中。
   * 同步阻塞：运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。
   * 其他阻塞：运行(running)的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行(runnable)状态。

   • 当前线程T调用Thread.sleep()方法，当前线程进入阻塞状态。
   • 运行在当前线程里的其它线程t2调用join()方法，当前线程进入阻塞状态。
   • 等待用户输入的时候，当前线程进入阻塞状态。

5. 死亡(DEAD)：线程run()、main() 方法执行结束，或者因异常退出了run()方法，则该线程结束生命周期。死亡的线程不可再次复生。

   • 当线程的run()方法完成时，或者主线程的main()方法完成时，我们就认为它死去。这个线程对象也许是活的，但是，它已经不是一个单独执行的线程
   • 在一个死去的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常。

线程的状态

说明1. 等待队列(本是Object里的方法，但影响了线程)
* 调用obj的wait(), notify()方法前，必须获得obj锁，也就是必须写在synchronized(obj) 代码段内。

说明2. 锁池
* 当前线程想调用对象A的同步方法时，发现对象A的锁被别的线程占有，此时当前线程进入锁池状态。简言之，锁池里面放的都是想争夺对象锁的线程。
* 当一个线程1被另外一个线程2唤醒时，1线程进入锁池状态，去争夺对象锁。
* 锁池是在同步的环境下才有的概念，一个对象对应一个锁池。

等待队列示意图

三、主要方法

1. Thread.sleep(long millis)
   使当前线程（即调用该方法的线程）暂停执行一段时间，让其他线程有机会继续执行，但它并不释放对象锁。也就是说如果有synchronized同步快，其他线程仍然不能访问共享数据。如：高优先级线程sleep之后，可使低优先级线程获得执行机会。

   • 一定是当前线程调用此方法
   • 当前线程进入阻塞，但不释放对象锁
   • millis后线程自动苏醒进入可运行状态
   • 注意该方法也需要捕捉异常

2. Thread.yield()
   当前线程放弃获取的cpu时间片，由运行状态变会可运行状态，让调度机制再次选择线程，但它并不释放对象锁。实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。Thread.yield()不会导致阻塞。

其实yield()方法对应了如下操作：先检测当前是否有相同优先级的线程处于同可运行状态，如有，则把CPU的占有权交给次线程，否则继续运行原来的线程

* 一定是当前线程调用此方法
* 让相同优先级的线程轮流执行，但并不保证一定会轮流执行

3. threadB.join() / threadB.join(long millis)
   当前线程里调用其它线程（如threadB）的join方法，当前线程阻塞，但不释放对象锁，直到threadB执行完毕或者millis时间到，当前线程进入可运行状态。

   • 注意该方法也需要捕捉异常

4. object.wait()、object.notifyAll()、object.notify()
   这三个方法都是java.lang.Object的方法。用于协调多个线程对共享数据的存取，所以必须在synchronized语句块内使用。synchronized关键字用于保护共享数据，阻止其他线程对共享数据的存取，但是这样程序的流程就很不灵活了，如何才能在当前线程还没退出synchronized数据块时让其他线程也有机会访问共享数据呢？此时就用这三个方法来灵活控制。

当前线程调用对象的wait()方法，使当前线程暂停执行并释放对象锁，进入等待队列，让其他线程可以进入synchronized数据块。依靠notify() 、notifyAll()唤醒或者wait(long timeout)timeout时间到自动唤醒，从等待队列进入锁池，重新获取对象锁后可获取执行机会。

notify()唤醒在此对象监视器上等待的单个线程，选择是任意性的。只有当前线程已经获取到对象锁后，才可以调用该对象的 notify() 方法，否者会抛出IllegalMonitorStateException 异常。

notifyAll()唤醒在此对象监视器上等待的所有线程，使线程从等待队列进入锁池。

5. thread.interrupt()、thread.isInterrupted()、Thread.interrupted()
   thread.interrupt() 中断线程，仅仅设置线程的中断标志为 true 并立即返回，线程的运行状态并不会发生变化。

thread.isInterrupted() 检测当前线程是否被中断，如果是返回 true，否则返回 false。

Thread.interrupted() 静态方法
检测当前线程是否被中断，如果是返回 true，否则返回 false。与isInterrupted 不同的是，该方法发现当前线程被中断后会清除中断标志。
注意：当一个线程处于休眠（sleep）、等待（wait、join）的时候，如果其他线程中断了它，则处于休眠的线程会立即抛出 java.lang.InterruptedException 异常，并重置中断状态。Java 中的线程中断只是简单设置中断标志，至于剩下的事情就需要程序员自己来做，比如根据中断标志来判断是否退出执行。
在Android中如果只希望线程休眠而不希望被打断，可以使用SystemClock.sleep()来替代Thread.sleep()

(部分内容参考于网络，如有不妥，请联系删除～)