Android/java 多线程(一)-Thread的使用以及源码分析

线程的概念以及状态

在学习线程之前，我们需要普及一个概念，每一个程序运行都会有一个父进程，我们的线程就是在此父进程中运行，拿Android来说，默认情况下，启动一个程序，所有的组件程序都运行在同一个进程中，并且会创立一个执行线程在该进程中，俗称”主线程”,当我们在该线程中做了耗时的操作造成了程序卡慢，我们就叫“线程阻塞”了,此时就应该另起一个线程来执行耗时操作。

要理解线程中方法的使用，就得先理解线程的运行状态，线程从创立到执行完毕，一共有6个状态：

• NEW(线程创立未启动)
• RUNNABLE(正在执行中的线程)
• BLOCKED(被阻塞并且在等待监视器锁释放)
• WAITING(等待被唤醒)
• TIMED_WAITING(等待或者睡眠肯定时间被唤醒)
• TERMINATED（线程终止，消亡）

这些状态对应Thread源码中的State枚举，通过getState()方法可以获取该线程的运行状态

其中BLOCKED表示等待监视器锁的过程，那么什么是监视器锁呢，监视器锁是为理解决线程不安全而诞生的方法，当多个进程同时操作一个数据结构并修改时，这时数据结构是不确定的，我们称之为“线程不安全”,于是我们使用synchronized(同步锁)和lock锁等机制来处理这种线程不安全，套上此锁，当前有且只有一个线程能修改此数据结构，其余的线程则需要等待，这就保证了数据结构的一致性，而其余线程会进入等待的状态，也就是我们的BLOCKED状态。
synchronized使用示例：

    class MyThread extends Thread {        @Override        public void run() {            synchronized (this) {                //这里写修改数据源的代码            }        }    }

lock使用示例：

    class MyThread extends Thread {        private final ReentrantLock lock = new ReentrantLock ();                @Override        public void run() {            lock.lock();                //这里写修改数据源的代码            lock.unlock();        }    }

当然这两者的应用不仅仅是在线程中，在必要的方法调用上也可使用

线程的源码以及方法使用

Thread源码：

public class Thread implements Runnable { ...........    /* Some of these are accessed directly by the VM; do not rename them. */    private volatile long nativePeer;    volatile ThreadGroup group;    volatile boolean daemon;    volatile String name;    volatile int priority;    volatile long stackSize;    Runnable target;    private static int count = 0;    private long threadInitNumber ;    /**     * Normal thread local values.     */    ThreadLocal.Values localValues;    /**     * Inheritable thread local values.     */    ThreadLocal.Values inheritableValues;    /** Callbacks to run on interruption. */    private final List<Runnable> interruptActions = new ArrayList<Runnable>();    /**     * Holds the class loader for this Thread, in case there is one.     */    private ClassLoader contextClassLoader;    /**     * Holds the handler for uncaught exceptions in this Thread,     * in case there is one.     */    private UncaughtExceptionHandler uncaughtHandler;    /**     * Holds the default handler for uncaught exceptions, in case there is one.     */    private static UncaughtExceptionHandler defaultUncaughtHandler;   .....}

Thread实现了Runnable接口，并公告了少量线程常用的少量变量:

• group
  线程组，线程组包含其余的线程组，形成了一个树结构，除了初始的线程组外，其余的线程组都会有个父进程，其中线程能访问当前线程组的信息，但不能访问父线程组的信息

• daemon
  能否是守护线程，啥是守护线程呢，守护线程是依赖于创立它的线程的一种线程，与普通线程的区别是当创立它的线程关闭了那它也会关闭，而普通线程不会，像我们的垃圾收集器线程就是一个守护线程

• threadInitNumber 当前线程的标识符，它是按照线程的创立顺序来叠加的

• name 线程的名称，未指定的话就以"Thread-" + threadInitNumber的逻辑命名

• priority
  线程优先级，有三个状态MIN_PRIORITY,NORM_PRIORITY,MAX_PRIORITY,分别对应低，中，高

• stackSize 堆栈大小

• target 当前的目标线程

• contextClassLoader 类加载器，用于保存该线程的信息，断点续传等功能可以用到

• uncaughtHandler
  线程未捕获异常调用类，假如没有对其进行设置，将会默认使用defaultUncaughtHandler来解决异常，因为我们的主线程也是一个Thread,所以我们可以通过实现UncaughtExceptionHandler接口并调用Thread.setDefaultUncaughtExceptionHandler（）方法将我们自己设置的异常捕获类设置给Thread,这样我们即可以捕获全局的异常

理解了少量常用变量后，我们再来看一下其中的少量常用方法:

start()方法

用于启动一个线程，只有调用此方法，系统才会新开启一个线程并分配给其必要的资源。我们看一下Thread的构造方法，发现最终都是调用了init方法，里面也只是对基本变量进行初始化，并没有分配到任何的资源：

    private void init(ThreadGroup g, Runnable target, String name, long stackSize) {        Thread parent = currentThread();        if (g == null) {            g = parent.getThreadGroup();        }        g.addUnstarted();        this.group = g;        this.target = target;        this.priority = parent.getPriority();        this.daemon = parent.isDaemon();        setName(name);        init2(parent);        /* Stash the specified stack size in case the VM cares */        this.stackSize = stackSize;        tid = nextThreadID();    }

所以，新建一个线程不会消耗资源，只有当star后才会去分配必要的资源，此时线程状态由NEW变为了RUNNABLE

run()方法

此方法用于解决线程中执行的逻辑，假如继承Thread类则必需重写该方法

sleep()方法

sleep(long millis)     //参数为毫秒sleep(long millis,int nanoseconds)    //第一参数为毫秒，第二个参数为纳秒

让线程休眠一段时间，相当于让线程进入阻塞状态。注意即便线程休眠了其锁机制仍旧生效，其余的线程仍旧不能访问其被锁的数据结构，直到其释放对象锁，此时线程状态由RUNNABLE进入TIMED_WAITING

yield()方法

让当前线程交出相应的权限，为其余线程退让，这是防止CPU过度使用的一种有效手段。效果与sleep差不多，但不能指定具体的时间，并且并不是让线程进入到阻塞状态，而是进入就绪状态.此时线程状态由RUNNABLE进入WAITING

join()方法

join()join(long millis)     //参数为毫秒join(long millis,int nanoseconds)    //第一参数为毫秒，第二个参数为纳秒

此方法是让线程优先来执行，其他的线程会暂停，直到此线程执行完毕才会继续执行。你可以将线程看成少量正常行驶的车辆(在线程队列中)，当给其中一辆车使用了join(弯道超车),那其他的车会给其让行（线程进入暂停状态），优先让它行驶(join的线程运行)，直到它到达终点(运行完成)，才会继续行驶（继续执行）
而join源码中是调用的wait()方法，而wait()方法能使线程进入阻塞状态并释放对象锁，所以join方法也是能释放对象锁的

interrupt（）方法

中断线程，我们知道，线程执行完run方法里的逻辑就会进入终止状态。调用此方法会使一个阻塞的线程抛出InterruptedException异常，从而终止线程，可以调用isInterrupted()判断能否终止了线程，但非阻塞线程如何中断呢，请看：

class MyThread extends Thread{        private volatile boolean isStop = false;        @Override        public void run() {            int i = 0;            while(!isStop){                i++;            }        }                 public void setStop(boolean stop){            this.isStop = stop;        }    }

我们可以设置一个变量来控制能否执行完毕，从而结束线程，此时线程状态进入TERMINATED状态