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

2023年9月17日 138次阅读 来源: 我是黄教主啊

线程的概念以及状态

在学习线程之前，我们需要普及一个概念，每一个程序运行都会有一个父进程，我们的线程就是在此父进程中运行，拿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
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞