Android多线程（一）

Android 线程简单分析（一）
Android 并发之synchronized锁住的是代码还是对象（二）
Android 并发之CountDownLatch、CyclicBarrier的简单应用（三）
Android 并发HashMap和ConcurrentHashMap的简单应用（四）(待发布)
Android 并发之Lock、ReadWriteLock和Condition的简单应用(五)
Android 并发之CAS（原子操作）简单介绍（六）
Android 并发Kotlin协程的重要性（七）(待发布)
Android 并发之AsyncTask原理分析（八）
Android 并发之Handler、Looper、MessageQueue和ThreadLocal消息机制原理分析（九）
Android 并发之HandlerThread和IntentService原理分析（十）

概述

Android沿用了Java的线程模型，一个Android应用对应着一个进程，同时会开启一个线程称为主线程或者UI线程，如果我们想要访问网络或者访问数据库等耗时的操作时，都会开启一个子线程去处理，从Android 3.0开始，系统为了避免阻塞主线程，要求网络访问必须在子线程中进行，否则将抛出异常。下面这张图是我的要讲的多线程体系导图：

多线程体系.png

1、进程和线程简介

提到线程，不得不提进程。进程是操作系统结构的基础，是程序在一个数据集合上运行的过程，是系统进行资源分配和调度的基本单位。同时进程可以被看做程序的实体，也是线程的容器。Android应用可以被看做是一个进程，但是Android系统默认分配的内存是有限的，很多开发人员为了解决这个瓶颈，引入了多进程开发，看一下我在Windows下任务管理器，列表里面的.exe程序就是一个进程，第二张图是在Android Studio下对应的一个进程，以gradle下的applicationId为进程ID，一般都是以包名命名：

image.png

image.png

1.2 线程状态

开始之前说一下时间片，时间片就时cpu分配给线程运行的时间，当时间到了线程将暂停，知道cpu重新分配时间，举个栗子：假如cpu是单核，那么同时只能运行一个线程，cpu就时这样不断切换，给人一种程序时并发运行的，其实不是的，只是这段时间比较短，我们是感觉不到的。
Java线程运行的声明周期中可能会处于5种不同的状态，Java中的线程的生命周期大体可分为5种状态。这5种状态分别如下：

1. 新建(NEW)：新创建了一个线程对象。
2. 可运行(RUNNABLE)：线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu 的使用权 。
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)状态。

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

   
   
   

   线程状态.jpg

• 初始状态（new）
  实现Runnable接口和继承Thread可以得到一个线程类，new一个实例出来，线程就进入了初始状态
• 可运行状态（Rannable）
  1、可运行状态(Rannable)只是说你资格运行，调度程序没有挑选到你，你就永远是可运行状态。
  2、调用线程的start()方法，此线程进入可运行状态。
  3、当前线程sleep()方法结束，其他线程join()结束，等待用户输入完毕，某个线程拿到对象锁，这些线程也将进入可运行状态。
  4、当前线程时间片用完了，调用当前线程的yield()方法，当前线程进入可运行状态。
  5、锁池里的线程拿到对象锁后，进入可运行状态。
• 运行状态(Running)
  1、线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一一种方式。
  *死亡状态
  1、当线程的run()方法完成时，或者主线程的main()方法完成时，我们就认为它死去。这个线程对象也许是活的，但是，它已经不是一个单独执行的线程。线程一旦死亡，就不能复生。
  2、在一个死去的线程上调用start()方法，会抛出ava.lang.IllegalThreadStateException异常。
• 阻塞状态
  1、当前线程T调用Thread.sleep()方法，当前线程进入阻塞状态。
  2、运行在当前线程里的其它线程t2调用join()方法，当前线程进入阻塞状态。
  3、等待用户输入的时候，当前线程进入阻塞状态。

• 等待队列(本是Object里的方法，但影响了线程)
  1、调用obj的wait(), notify()方法前，必须获得obj锁，也就是必须写在synchronized(obj) 代码段内。
  2、与等待队列相关的步骤和图
  2.1、线程1获取对象A的锁，正在使用对象A。
  2.2、线程1调用对象A的wait()方法。
  2.3、线程1释放对象A的锁，并马上进入等待队列。
  2.4、锁池里面的对象争抢对象A的锁。
  2.5、线程5获得对象A的锁，进入synchronized块，使用对象A。
  2.6、线程5调用对象A的notifyAll()方法，唤醒所有线程，所有线程进入锁池。||||| 线程5调用对象A的notify()方法，唤醒一个线程，不知道会唤醒谁，被唤醒的那个线程进入锁池。
  2.7、notifyAll()方法所在synchronized结束，线程5释放对象A的锁。
  锁池里面的线程争抢对象锁，但线程1什么时候能抢到就不知道了。||||| 原本锁池+第6步被唤醒的线程一起争抢对象锁。

  
  
  

  阻塞队列.jpg
  
  

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

• 几个方法的比较
  1、Thread.sleep(long millis)，一定是当前线程调用此方法，当前线程进入阻塞，但不释放对象锁，millis后线程自动苏醒进入可运行状态。作用：给其它线程执行机会的最佳方式。
  2、Thread.yield()，一定是当前线程调用此方法，当前线程放弃获取的cpu时间片，由运行状态变会可运行状态，让OS再次选择线程。作用：让相同优先级的线程轮流执行，但并不保证一定会轮流执行。实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。Thread.yield()不会导致阻塞。
  3、t.join()/t.join(long millis)，当前线程里调用其它线程1的join方法，当前线程阻塞，但不释放对象锁，直到线程1执行完毕或者millis时间到，当前线程进入可运行状态。
  4、obj.wait()，当前线程调用对象的wait()方法，当前线程释放对象锁，进入等待队列。依靠notify()/notifyAll()唤醒或者wait(long timeout)timeout时间到自动唤醒。
  5、obj.notify()唤醒在此对象监视器上等待的单个线程，选择是任意性的。notifyAll()唤醒在此对象监视器上等待的所有线程。
• 两个疑问
  1、当对象锁被某一线程释放的一瞬间，锁池里面的哪个线程能获得这个锁？随机？，我觉得应该是竞争锁，也是随机的。
  2、等待队列里许许多多的线程都wait()在一个对象上，此时某一线程调用了对象的notify()方法，那唤醒的到底是哪个线程？java文档就简单的写了句：选择是任意性的。

如何创建线程？

1、继承Thread类，重写run方法：

 static class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("my thread");
    }
}
public static void main(String[] args) {
    MyThread myThread = new MyThread();
    myThread.start();
}

Thread本质上也是实现了Runnable接口。需要注意的是调用thread.start方法后并不能立即执行线程，而是线程的状态变为可运行的状态，等待CPU的调度。

2、实现Callable接口，重写call方法

static class MyCallable implements Callable {

    @Override
    public String call() throws Exception {
        Thread.sleep(3000);
        return "hahah";
    }
}

public static void main(String[] args) throws ExecutionException, InterruptedException {
    System.out.println("start MyCallable");
    Future future = executorService.submit(new MyCallable());
    String result = future.get();
    System.out.println("result: " + result);
}

Callable实际上是属于Executor框架中的功能类，Callable接口与Runnable接口的功能是类似的，但比Runnable更强大。

• Callable中call方法可以在任务执行完成提供一个返回值，Runanble接口是无法做到的。
• Callable接口的call方法可以跑出异常，而Runnable接口的run方法无法跑出异常。
• 运行Callable可以得到一个Future对象，Future对象表示异步计算的结果，它提供了检查计算是否完成，通过Future的get方法获取目标线程call方法的情况，Future的get方法会阻塞当前线程知道call方法返回值会用或者抛出异常，或者get方法设置超时。