Android 多线程编程初探

       Android 中的多线程其实就是 java SE 中的多线程，只是为了方便使用，Android 封装了一些类，如 AsyncTask、HandlerThread 等，在日常的开发过程中，我们往往需要去执行一些耗时的操作，例如发起网络请求，考虑到网速等其他外在的因素，服务器可能不会立刻响应我们的请求，如果不将这条操作放到子线程中去执行，就会造成主线程被阻塞，今天我们就从多线程的基础来一起探讨，来概览今天的内容

一、线程的基本用法

对于 Andorid 多线程来说我们最新接触到的就是 Thread 和 Runnable 通常我们如下来启动一个新的线程

1）继承自 Thread 来创建子线程

定义一个线程只需要新建一个类继承自 Thread，然后重写父类的 run 方法即可

    /**
     * 继承 Thread 创建子线程
     */
    class MyThread extends Thread {
        @Override
        public void run() {
            //处理具体的逻辑
        }
    }

那么如何启动这个线程呢？只需要 new 出 MyThread 的实例，然后调用它的 start() 方法，这样 run() 方法中的代码就会运行在子线程，如下：

    new MyThread().start();

2）实现 Runnable 接口来创建子线程

继承方式耦合性高，更多时候我们会选择实现 Runnable 接口的方式来实现一个子线程，如下：

    /**
     * 实现 Runnable 接口创建子线程
     */
    class MyThread implements Runnable {
        @Override
        public void run() {
            //处理具体的逻辑
        }
    }

如果使用这种写法，启动线程的方法也需要相应的改变，如下：

        MyThread myThread = new MyThread();
        new Thread(myThread).start();

Thread 构造函数接受一个 Runnable 参数，我们 new 出的 MyThread 正是一个实现了 Runnable 接口的对象，所以可以直接将它传入到 Thread 的构造函数里，接着就和上面的一样了，调用 Thread 的 start() 方法，run() 方法中的代码就会在子线程当中运行了

3）直接使用匿名类来创建子线程

        new Thread(new Runnable() {
            @Override
            public void run() {
                //处理具体的逻辑
            }
        }).start();

如果你不想再定义一个类去实现 Runnable 接口，也可以使用如上匿名类的方式来实现，这种实现方式也是我们最常用到的

以上这些就是我们来创建子线程时使用的不方式，基本和 Java 中一样

4）Thread 和 Runnable 的区别

       实际上 Thread 也是一个 Runnable，它实现了 Runnable 接口，在Thread类中有一个 Runnable 类型的 target字段，代表要被执行在这个子线程中的任务，代码如下：

Thread 部分源码：

public class Thread implements Runnable {
    /* What will be run. */
    private Runnable target;
    /* The group of this thread */
    private ThreadGroup group;

    private String name;
    /*
   * The requested stack size for this thread, or 0 if the creator did
   * not specify a stack size.  It is up to the VM to do whatever it
   * likes with this number; some VMs will ignore it.
   */
    private long stackSize;

    /**
     * 初始化 Thread 并且将Thread 添加到 ThreadGroup 中
     *
     * @param g
     * @param target
     * @param name
     * @param stackSize
     */
    private void init(ThreadGroup g, Runnable target, String name, long stackSize) {
        java.lang.Thread parent = currentThread();
        //group 参数为空，则获取当前线程的才线程组
        if (g == null) {
            g = parent.getThreadGroup();
        }
        this.group = g;
        this.name = name;
        //设置 target
        this.target = target;
        /* Stash the specified stack size in case the VM cares */
        this.stackSize = stackSize;
    }

    public Thread() {
        init(null, null, null, 0);
    }

    public Thread(Runnable target) {
        init(null, target, null, 0);
    }

    public Thread(ThreadGroup group, Runnable target) {
        init(group, target, null, 0);
    }

    public Thread(Runnable target, String name) {
        init(null, target, name, 0);
    }

    public Thread(ThreadGroup group, Runnable target, String name) {
        init(group, target, name, 0);
    }

    public Thread(ThreadGroup group, Runnable target, String name,
                  long stackSize) {
        init(group, target, name, stackSize);
    }

    /**
     * 启动一个新的线程，如果target 不为空则执行 target 的 run 函数
     * 否者执行当前对象的run()方法
     */
    public synchronized void start() {
        //调用 nativeCreate 启动新线程
        nativeCreate(this, stackSize, daemon);
        started = true;
    }

    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
}

      上面是 Thread 的部分源码，我们看到其实 Thread 也实现了 Runnable 接口，最终被线程执行的是 Runnable，而非 Thread，Thread 只是对 Runnable 的包装，并且通过一些状态对 Thread 进行管理与调度，Runnable 定义了可执行的任务它只有一个无返回值的 run() 函数，如下：

    public interface Runnable {
        /**
         * When an object implementing interface <code>Runnable</code> is used
         * to create a thread, starting the thread causes the object's
         * <code>run</code> method to be called in that separately executing
         * thread.
         * <p>
         * The general contract of the method <code>run</code> is that it may
         * take any action whatsoever.
         *
         * @see java.lang.Thread#run()
         */
        public abstract void run();
    }

当启动一个线程时，如果 Thread 的 Target 不为空时，则会在子线程中执行这个 target 的 run() 函数，否则虚拟机就会执行该线程自身的 run() 函数

二、线程的 wait、sleep、join、yield

       Thread 的基本用法相对来说比较简单，通常就是复写 run() 函数，然后调用线程的 start() 方法启动线程，接下来我们来看看 wait、sleep、join、yield 的区别

1）wait

       当一个线程执行到 wait() 方法时，它就进入到一个和该对象相关的等待池中，同时释放对象的机锁，使得其它线程可以访问，用户可以使用 notify、nitifyAll 或者指定睡眠时间来唤醒当前等待池中的线程，注意：wait()、notify()、notifyAll() 必须放在 Synchronized 块中，否则会抛出异常

2）sleep

       该函数是 Thread 的静态函数，作用是使调用线程进入睡眠状态，因为 sleep() 是 Thread 类的静态方法，因此它不能改变对象锁，所以当在一个 Synchronized 块中调用 sleep() 方法时，线程虽然休眠了，但是对象的锁并没有被释放，其它线程无法访问这个对象，即使睡眠也持有对象的锁

3）join

等待目标线程执行完之后再继续执行

4）yield

线程礼让，目标线程由运行状态转换为就绪状态，也就是让出执行权限，让其它线程可以优先执行，但其他线程能否优先执行未知

三、线程池

       当我们需要频繁的创建多个线程进行耗时操作时，每次都经过 new Thread 实现并不是一种好的方式，每次 new Thread 新建和销毁对象的性能较差，线程缺乏统一管理，可能无限制新建线程，相互之间竞争，可能占用过多系统资源导致死锁，并且缺乏定时执行，定期执行，线程中断等功能，Java 提供了 4 种线程池，它能够有效的管理，调度线程，避免过多的浪费系统资源，它的优点如下：

1）重用存在的线程，减少对象创建，销毁的开销

2）可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多的资源竞争，避免堵塞

3）提供定时执行、定期执行、单线程、并发数控制等功能

       简单来说，线程池原理简单的解释就是会创建多个线程并进行管理，提交给线程的任务会被线程池指派给其中的线程进行执行，通过线程池的统一调度、管理使得多线程使用更加简单、高效，如下图：

       线程池都实现了 ExecutorService 接口，改接口定义了线程池需要实现的接口，它的实现有  ThreadPoolExecutor 和 ScheduledThreadPoolExecutor，ThreadPoolExecutor 也就是我们运用最多的线程池实现，ScheduledThreadPoolExecutor 用于周期性执行任务，通常我们都不会直接通过 new 的形式来创建线程池，由于创建参数过程相对复杂一些，因此 JDK 给我们提供了一个 Executor 工厂类来简化这个过程

线程池的使用准则：

1）不要对那些同步等待的其他任务结果的任务排队，这可能会导致死锁，在死锁中所有所有线程都被一些任务所占用，这些任务依次等待排队任务的结果，而这些任务又无法执行，因为所有的线程处于忙碌状态

2）理解任务，要有效的调整线程池的大小，你需要理解正在排队的任务以及它们正在做什么

3）调整线程池的大小基本上就是避免两类错误，线程太少或线程太多，幸运的是对于大多数应用程序来说，太多和太少之间的余地相当宽

今天介绍的基本都是一些理论的东西，有的看起来可能没劲，大家就当了解一下吧，又到周五了，祝大家周末愉快

参考：郭神第一行代码，Android 进阶