android线程管理二（Thread）

最新推荐文章于 2025-03-11 00:20:01 发布

Lu'Blog

最新推荐文章于 2025-03-11 00:20:01 发布

阅读量1.3k

点赞数 1

分类专栏：进程与线程山涧晴岚文章标签：线程 Android Thread

本文链接：https://blog.youkuaiyun.com/lu1024188315/article/details/75151523

版权

山涧晴岚同时被 2 个专栏收录

11 篇文章

订阅专栏

进程与线程

6 篇文章

订阅专栏

本文详细解析 Java 中 Thread 类的结构、构造方法、初始化过程及线程的生命周期，同时还介绍了 start、interrupt、join 等核心方法的工作原理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

前言

本篇主要从源码上分析一下 Thread，转载请注明出处：小石头的博客 http://blog.youkuaiyun.com/lu1024188315/article/details/74518599

一结构关系

public class Thread implements Runnable {

  ......
}

很显然 Thread继承了Runnable。

Runnable源码如下：

public interface Runnable {
    public abstract void run();
}

Runnable很简单，它是一个接口，只用一个方法run();

二构造函数

Thread#构造方法：

public Thread() {
        init(null, null, "Thread-" + nextThreadNum(), 0);
}

public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
}

public Thread(ThreadGroup group, Runnable target) {
        init(group, target, "Thread-" + nextThreadNum(), 0);
}

......

说明，这只是部分构造方法，从这些构造方法中可以看出都是调用了函数 init。

Thread# init ：

/**
     * 很明显这个方法是用来初始化线程的
     * @param g 线程组 你创建的线程最终会被添加到这个线程组中
     * @param target  Runnable类型 用于回调
     * @param name 即将创建的线程的名字
     * @param stackSize 即将创建的线程的栈的大小，如果是0，表明忽略此参数
     */
    private void init(ThreadGroup g, Runnable target, String name, long stackSize) {
        //调用native层的currentThread函数获取当前环境所在的线程，例如在Activity中，你获取的将是UI线程
        Thread parent = currentThread();
        if (g == null) {
           //线程parent所属的线程组
            g = parent.getThreadGroup();
        }
        //函数1 后台线程数加1 
        g.addUnstarted();
        //保存线程组
        this.group = g;
        //保存  Runnable类型 用于回调
        this.target = target;
        //parent获取线程优先权1-10
        this.priority = parent.getPriority();
        //是否是后台线程
        this.daemon = parent.isDaemon();
        //设置线程的名字
        setName(name);
        //函数2 
        init2(parent);

        /* Stash the specified stack size in case the VM cares */
        this.stackSize = stackSize;
        //创建线程Id，线程的唯一标识
        tid = nextThreadID();
    }

1 addUnstarted

Thread# addUnstarted ：

void addUnstarted() {
        synchronized(this) {
            if (destroyed) {
                throw new IllegalThreadStateException();
            }
            nUnstartedThreads++;
        }
}

注释已经说的很清楚了：

/**
 * Increments the count of unstarted threads in the thread group.
 * Unstarted threads are not added to the thread group so that they
 * can be collected if they are never started, but they must be
 * counted so that daemon thread groups with unstarted threads in
 * them are not destroyed.
 */

大致意思就是：把 thread group 中的即将启动的线程数加一，这样可以在该线程没有启动的情况，避免被销毁。

2 int2

Thread# int2 ：

private void init2(Thread parent) {
        //获取线程parent的类加载器 ClassLoader类型
        this.contextClassLoader = parent.getContextClassLoader();
        this.inheritedAccessControlContext = AccessController.getContext();
        if (parent.inheritableThreadLocals != null) {
            //给当前线程创建ThreadLocalMap对象，并且继承parent的ThreadLocalMap中的数据
            this.inheritableThreadLocals = ThreadLocal.createInheritedMap(
                    parent.inheritableThreadLocals);
        }
}

说明，这里有两点需要注意下：

a ：类加载器即ClassLoader，那么什么是类加载器？一个完整的Java程序可能由几个.class文件组成，程序在运行的过程中并不是一下子把所有的.class文件放置内存中，而是通过类加载器把需要的.class文件加载到内存中，进而其他的.class文件可访问到这个该.class文件。想了解更多关于ClassLoader，可以参考这篇《深入分析Java 类加载器》文章。

b：ThreadLocalMap 它是ThreadLocal的内部类，每个Thread都一个 ThreadLocalMap，其结构是Map类型，key存储的是当前线程的ThreadLocal对象，value存储的是Object类型的变量，其作用使用 ThreadLocal声明一个变量时， ThreadLocal会为每个线程创建这个变量的副本，当线程对这个变量进行操作时，互相之间不受影响，在一定程度上解决多线程不安全的问题。关于 ThreadLocal以后会详细介绍。

三生命周期

1线程状态

public enum State {
        NEW,//被实例化之后,但还没有调用start启动
        RUNNABLE,//调用了start函数之后就处于Runnable状态 
        BLOCKED,//调用join()、sleep()、wait()使线程处于Blocked状态
        WAITING,//
        TIMED_WAITING,//
        TERMINATED;//
}

(1) new

new也称为新线程状态，通过new关键字实例化一个Thread对象就生成一个新线程。当线程处于"新线程"状态时，仅仅是一个空线程对象，它还没有分配到系统资源。因此只能启动或终止它。任何其他操作都会引发异常。例如，一个线程调用了new方法之后，并在调用start方法之前的处于新线程状态，可以调用start和stop方法。

(2)Runnable

Runnable也称为可运行状态，通过start方法后使线程处于该状态，此时线程获取了支持其运行的资源，并调度其run方法，这个状态不能想当然的认为是运行状态，因为这时的线程并不总是一直占用处理机，它也有可能不在运行，这是因为还有优先级和调度问题。特别是对于只有一个处理机的PC而言，任何时刻只能有一个处于可运行状态的线程占用处理机。Java通过调度来实现多线程对处理机的共享。

(3)NOT Runnable

NOT Runnable也称为阻塞状态，当以下事件发生时，线程处于该状态：

a：调用supped、sleep方法

b：调用wait方法等待条件变量

c：线程处于I／O请求的等待

(4)Dead

Dead 也称为死亡状态，run方法运行完毕、其他线程调用该线程的stop方法、异常终止都会使线程处理该状态。

2 线程的操作：

派生：线程在进程内派生出来，它即可由进程派生，也可由线程派生。

阻塞（Block）：如果一个线程在执行过程中需要等待某个事件发生，则被阻塞。

激活（unblock）：如果阻塞线程的事件发生，则该线程被激活并进入就绪队列。

调度（schedule）：选择一个就绪线程进入执行状态。

结束（Finish）：如果一个线程执行结束，它的寄存器上下文以及堆栈内容等将被释放。

好，接下来借用网友一幅图加于说明：

四函数分析

1 start函数分析

一个线程启动调用的是start函数，下面我们看下它的源码：

Thread# start ：

public synchronized void start() {
        /**
         *threadStatus ==0，说明该线程状态为"NEW"，还没有启动过，一个线程只能启动一次，否则抛出异常。
         */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        /* 把当前线程添加到线程组中 */
        group.add(this);

        started = false;
        try {
            //调用native层函数创建线程，native层的源码未找到先不讨论它
            nativeCreate(this, stackSize, daemon);
            started = true;
        } finally {
            ......
        }
}

说明，这个方法主要两个作用：

a：把线程添加到线程组中

b：调用native层的nativeCreate函数完成线程的创建。

2 interrupt函数分析

Thread# interrupt ：

public void interrupt() {
        if (this != Thread.currentThread())
            checkAccess();
        //blockerLock
        synchronized (blockerLock) {
            Interruptible b = blocker;
            if (b != null) {
                nativeInterrupt();
                b.interrupt(this);
                return;
            }
        }//调用native层函数完成线程中断
        nativeInterrupt();
}

说明，在Java中“中断”线程是通过interrupt()方法来实现的，之所以加引号，是因为interrupt()并不中断正在运行的线程，只是向线程发送一个中断请求，具体行为依赖于线程的状态，如下：

a：如果线程处于阻塞状态，即线程被Object.wait()、Thread.join()或 Thread.sleep()阻塞，调用interrupt()方法，将接收到InterruptedException异常，中断状态被清除，结束阻塞状态；

b：如果线程在进行I/O操作（java.nio.channels.InterruptibleChannel）时被阻塞，那么线程将收到java.nio.channels.ClosedByInterruptException异常，通道被关闭，结束阻塞状态；

c：如果线程被阻塞在java.nio.channels.Selector中，那么中断状态会被置位并返回，不会抛出异常。

3 join函数分析

Thread# join ：

public final void join() throws InterruptedException {
        join(0);
}
public final void join(long millis) throws InterruptedException {
        synchronized(lock) {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (millis == 0) {
            while (isAlive()) {
                lock.wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                lock.wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
        }
}

说明，join()方法也可以理解为线程之间协作的一种方式，当两个线程需要顺序执行时，调用第一个线程的join()方法能使该线程阻塞，其依然通过wait()方法来实现的。

4 sleep与wait函数分析

Thread# sleep ：

public static void sleep(long millis) throws InterruptedException {
        Thread.sleep(millis, 0);
}

Thread# wait ：

public final void wait(long millis) throws InterruptedException {
        wait(millis, 0);
}

说明，sleep()与wait()的相同之处在于它们都是通过等待阻塞线程，不同之处在于sleep()等待的是时间，wait()等待的是对象的锁，在这里是看不出来的。

5 常用函数总结

run()：包含线程运行时所执行的代码

start()：用于启动线程

sleep()、sleep(long millis)：线程休眠，交出CPU，让CPU去执行其他的任务，然后线程进入阻塞状态，sleep方法不会释放锁

yield()：使当前线程交出CPU，让CPU去执行其他的任务，但不会是线程进入阻塞状态，而是重置为就绪状态，yield方法不会释放锁

join()、join(long millis)、join(long millis,int nanoseconds)：等待线程终止，直白的说就是发起该子线程的线程只有等待该子线程运行结束才能继续往下运行

wait()：交出cpu，让CPU去执行其他的任务，让线程进入阻塞状态，同时也会释放锁

interrupt()：中断线程，自stop函数过时之后，我们通过interrupt方法和isInterrupted()方法来停止正在运行的线程，注意只能中断已经处于阻塞的线程

getId()：获取当前线程的ID

getName()、setName()：获取和设置线程的名字

getPriority()、setPriority()：获取和这是线程的优先级一般property用1-10的整数表示，默认优先级是5，优先级最高是10，优先级高的线程被执行的机率高

setDaemon()、isDaemo()：设置和判断是否是守护线程

currentThread()：静态函数获取当前线程

参考文献

1《android 进程/线程管理（二）----关于线程的迷思》

2《 Android线程管理之Thread使用总结》

3《 Thread类的内部原理、休眠及唤醒》