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状态

    原文作者:我是黄教主啊
    原文地址: https://www.jianshu.com/p/853be38bcd0a
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞