22.jdk源码阅读之Thread(上)

于 2024-07-27 14:56:25 发布
阅读量732 收藏 30
点赞数 15
分类专栏： JDK源码 文章标签： java 开发语言
本文为 至真源 原创，转载请注明出处，谢谢！
本文链接：https://blog.csdn.net/yunkongbian2616/article/details/140734997
版权

1. 写在前面

Java 中的 Thread 类是多线程编程的基础，也是我们日常工作中用的比较多的类，但是你真的了解它吗？下面这几个问题你是否有思考过？

  1. start() 和 run() 方法有什么区别？
  2. 什么是线程的生命周期？
  3. 什么是守护线程（Daemon Thread）？
  4. 如何中断线程？
  5. 什么是线程优先级？
  6. 什么是线程组（ThreadGroup）？
  7. 什么是线程本地变量（ThreadLocal）？
  8. 什么是死锁？如何避免

2. 全局视角

在这里插入图片描述

2.1 Runnable 接口

  • 定义了一个方法 run()，需要实现该接口的类提供具体的任务执行逻辑。
  • Thread 类通过实现 Runnable 接口，使得线程对象可以直接执行任务。
public interface Runnable {
    public abstract void run();
}

2.2 Thread 类的部分重要方法

  • start()：启动线程，调用 run() 方法。
  • run()：线程执行的任务逻辑，通常需要重写。
  • join()：等待线程终止。
  • sleep(long millis)：使当前线程休眠指定的毫秒数。
  • interrupt()：中断线程。
  • isInterrupted()：检查线程是否被中断。
  • setDaemon(boolean on)：将线程设置为守护线程
  • getPriority() 和 setPriority(int newPriority)：获取和设置线程的优先级。
  • getName() 和 setName(String name)：获取和设置线程的名称。
  • getState()：获取线程的状态。

2.3 Thread 类的构造方法

在这里插入图片描述

Thread 类提供了多种构造方法，以便灵活创建线程对象。常见的构造方法包括：

  • Thread()
  • Thread(Runnable target)
  • Thread(Runnable target, String name)
  • Thread(String name)
  • Thread(ThreadGroup group, Runnable target)
  • Thread(ThreadGroup group, Runnable target, String name)

下面我们来详细介绍下各个构造方法是如何使用的。

3. 从使用说起

3.1 无参构造方法

无参构造方法创建一个新的线程对象，但不指定任何任务或线程名称。

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread() {
            @Override
            public void run() {
                System.out.println("Thread running using no-arg constructor");
            }
        };
        thread.start();
    }
}

3.2 使用 Runnable 作为参数的构造方法

这个构造方法接受一个实现了 Runnable 接口的对象作为参数，用于指定线程要执行的任务。

public class Main {
    public static void main(String[] args) {
        Runnable task = new Runnable() {
            @Override
            public void run() {
                System.out.println("Thread running using Runnable constructor");
            }
        };
        Thread thread = new Thread(task);
        thread.start();
    }
}

3.3 使用 Runnable 和 String 作为参数的构造方法

这个构造方法接受一个实现了 Runnable 接口的对象和一个线程名称，用于指定线程要执行的任务和线程的名称。

public class Main {
    public static void main(String[] args) {
        Runnable task = new Runnable() {
            @Override
            public void run() {
                System.out.println("Thread running using Runnable and String constructor");
            }
        };
        Thread thread = new Thread(task, "MyThread");
        thread.start();
        System.out.println("Thread Name: " + thread.getName());
    }
}

3.4 使用 String 作为参数的构造方法

这个构造方法接受一个线程名称，用于指定线程的名称。

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread("MyThread") {
            @Override
            public void run() {
                System.out.println("Thread running using String constructor");
            }
        };
        thread.start();
        System.out.println("Thread Name: " + thread.getName());
    }
}

3.5 使用 ThreadGroup 和 Runnable 作为参数的构造方法

这个构造方法接受一个线程组和一个实现了 Runnable 接口的对象，用于指定线程所属的线程组和要执行的任务。

public class Main {
    public static void main(String[] args) {
        ThreadGroup group = new ThreadGroup("MyGroup");
        Runnable task = new Runnable() {
            @Override
            public void run() {
                System.out.println("Thread running using ThreadGroup and Runnable constructor");
            }
        };
        Thread thread = new Thread(group, task);
        thread.start();
        System.out.println("Thread Group: " + thread.getThreadGroup().getName());
    }
}

3.6 使用 ThreadGroup, Runnable, 和 String 作为参数的构造方法

这个构造方法接受一个线程组、一个实现了 Runnable 接口的对象和一个线程名称，用于指定线程所属的线程组、要执行的任务和线程的名称。

public class Main {
    public static void main(String[] args) {
        ThreadGroup group = new ThreadGroup("MyGroup");
        Runnable task = new Runnable() {
            @Override
            public void run() {
                System.out.println("Thread running using ThreadGroup, Runnable, and String constructor");
            }
        };
        Thread thread = new Thread(group, task, "MyThread");
        thread.start();
        System.out.println("Thread Group: " + thread.getThreadGroup().getName());
        System.out.println("Thread Name: " + thread.getName());
    }
}

3.7 使用 ThreadGroup, Runnable, String, 和 long 作为参数的构造方法

这个构造方法接受一个线程组、一个实现了 Runnable 接口的对象、一个线程名称和一个栈大小，用于指定线程所属的线程组、要执行的任务、线程的名称和线程的栈大小。

public class Main {
    public static void main(String[] args) {
        ThreadGroup group = new ThreadGroup("MyGroup");
        Runnable task = new Runnable() {
            @Override
            public void run() {
                System.out.println("Thread running using ThreadGroup, Runnable, String, and long constructor");
            }
        };
        Thread thread = new Thread(group, task, "MyThread", 1024);
        thread.start();
        System.out.println("Thread Group: " + thread.getThreadGroup().getName());
        System.out.println("Thread Name: " + thread.getName());
    }
}

4. start()方法的底层源码

上面的使用中我们发现start()是用的比较多的一个方法，下面我们就深入看看它的源码实现，源码如下：

/**
     * Causes this thread to begin execution; the Java Virtual Machine
     * calls the <code>run</code> method of this thread.
     * <p>
     * The result is that two threads are running concurrently: the
     * current thread (which returns from the call to the
     * <code>start</code> method) and the other thread (which executes its
     * <code>run</code> method).
     * <p>
     * It is never legal to start a thread more than once.
     * In particular, a thread may not be restarted once it has completed
     * execution.
     *
     * @exception  IllegalThreadStateException  if the thread was already
     *               started.
     * @see        #run()
     * @see        #stop()
     */
    public synchronized void start() {
        /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }

start() 方法用于启动一个新线程，使其调用 run() 方法并在新的线程中执行。这个方法是线程启动的核心部分，确保线程正确地从 “NEW” 状态转变到 “RUNNABLE” 状态。下面是对这个方法的逐步解析：

4.1 方法签名

public synchronized void start() {
  • public：表示这个方法是公有的，可以从类的外部调用。
  • synchronized：表示这个方法是同步的，确保同一时间只有一个线程可以执行该方法，防止并发问题。

4.2 方法实现

    /**
     * This method is not invoked for the main method thread or "system"
     * group threads created/set up by the VM. Any new functionality added
     * to this method in the future may have to also be added to the VM.
     *
     * A zero status value corresponds to state "NEW".
     */

这段注释说明了 start() 方法的一些背景信息：

  • 这个方法不会被主线程或由虚拟机创建的 “系统” 线程调用。
  • 任何将来添加到这个方法的新功能也可能需要添加到虚拟机中。
  • threadStatus 为 0 表示线程处于 “NEW” 状态。
    if (threadStatus != 0)
        throw new IllegalThreadStateException();
  • 这段代码检查线程的状态。如果 threadStatus 不是 0（即线程不是处于 “NEW” 状态），则抛出 IllegalThreadStateException 异常。这确保了一个线程对象只能被启动一次。
    /* Notify the group that this thread is about to be started
     * so that it can be added to the group's list of threads
     * and the group's unstarted count can be decremented. */
    group.add(this);
  • 这段代码通知线程组（ThreadGroup）该线程即将启动。线程组会将该线程添加到其线程列表中，并减少未启动线程的计数。
    boolean started = false;
    try {
        start0();
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
            /* do nothing. If start0 threw a Throwable then
               it will be passed up the call stack */
        }
    }
  • boolean started = false;：初始化一个布尔变量 started 为 false，用于跟踪线程是否成功启动。
  • start0();：调用本地方法 start0()，这是一个本地方法，用于启动新线程。start0() 是一个私有的本地方法，由 JVM 实现，用来执行底层的线程启动操作。
  • started = true;：如果 start0() 成功执行，将 started 设置为 true。

4.3 finally 块

  • finally 块确保在任何情况下都能执行清理操作。
  • 如果 start0() 方法抛出异常且 started 仍然为 false，则调用 group.threadStartFailed(this); 通知线程组线程启动失败。
  • catch (Throwable ignore)：捕获所有异常，并忽略它们。这是为了确保如果 start0() 抛出异常，它会被传递到调用栈上，而不会被这个捕获块阻止。

5. run()方法

/**
     * If this thread was constructed using a separate
     * <code>Runnable</code> run object, then that
     * <code>Runnable</code> object's <code>run</code> method is called;
     * otherwise, this method does nothing and returns.
     * <p>
     * Subclasses of <code>Thread</code> should override this method.
     *
     * @see     #start()
     * @see     #stop()
     * @see     #Thread(ThreadGroup, Runnable, String)
     */
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

run()方法的源代码如上，看起来很简单，run() 方法是线程执行的入口点。当一个线程启动后，JVM 会调用该线程的 run() 方法。这个方法的默认实现检查线程是否有一个关联的 Runnable 对象，如果有，则调用该 Runnable 对象的 run() 方法。

5.1 方法签名和注释

/**
* If this thread was constructed using a separate
* <code>Runnable</code> run object, then that
* <code>Runnable</code> object's <code>run</code> method is called;
* otherwise, this method does nothing and returns.
* <p>
* Subclasses of <code>Thread</code> should override this method.
*
* @see     #start()
* @see     #stop()
* @see     #Thread(ThreadGroup, Runnable, String)
*/
@Override
public void run() {
  • 如果该线程是用一个单独的 Runnable 对象构造的，那么会调用这个 Runnable 对象的 run() 方法；否则，这个方法什么也不做，直接返回。
  • Thread 类的子类应该重写这个方法，以提供具体的执行逻辑。
  • 提供了一些相关方法的链接，包括 start()、stop() 和 Thread(ThreadGroup, Runnable, String)。

5.2 方法实现

    if (target != null) {
        target.run();
    }
}

  • if (target != null)

    • 检查 target 是否为 null。target 是一个 Runnable 对象，表示线程要执行的任务。
    • target 是 Thread 类的一个实例变量，当使用 Thread(Runnable target) 构造方法创建线程时，会将传入的 Runnable 对象赋值给 target。

  • target.run()

    • 如果 target 不为 null，则调用 target 的 run() 方法。这意味着如果线程是用一个 Runnable 对象创建的，那么实际执行的是这个 Runnable 对象的 run() 方法
    • 如果 target 为 null，则什么也不做，直接返回

5.3 例子

下面是一个使用 Thread 类和 Runnable 接口的示例，展示了如何使用 run() 方法：

5.3.1 使用 Runnable 接口

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable run method executed.");
    }
}

public class Main {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start(); // This will call myRunnable's run() method
    }
}

在这个例子中，MyRunnable 实现了 Runnable 接口，并重写了 run() 方法。创建 Thread 对象时，将 MyRunnable 对象传递给 Thread 的构造方法。调用 thread.start() 时，最终会调用 MyRunnable 对象的 run() 方法。

5.3.2 继承 Thread 类

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread run method executed.");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start(); // This will call MyThread's run() method
    }
}

在这个例子中，MyThread 继承了 Thread 类，并重写了 run() 方法。创建 MyThread 对象并调用 myThread.start() 时，会执行 MyThread 类的 run() 方法。

系列文章

1.JDK源码阅读之环境搭建

2.JDK源码阅读之目录介绍

3.jdk源码阅读之ArrayList(上)

4.jdk源码阅读之ArrayList(下)

5.jdk源码阅读之HashMap

6.jdk源码阅读之HashMap（下）

7.jdk源码阅读之ConcurrentHashMap(上)

8.jdk源码阅读之ConcurrentHashMap（下）

9.jdk源码阅读之ThreadLocal

10.jdk源码阅读之ReentrantLock

11.jdk源码阅读之CountDownLatch

12.jdk源码阅读之CyclicBarrier

13.jdk源码阅读之Semaphore

14.jdk源码阅读之线程池(上)

15.jdk源码阅读之线程池(下)

16.jdk源码阅读之ArrayBlockingQueue

17.jdk源码阅读之LinkedBlockingQueue

18.jdk源码阅读之CopyOnWriteArrayList

19.jdk源码阅读之FutureTask

20.jdk源码阅读之CompletableFuture

21.jdk源码阅读之AtomicLong

至真源
关注
专栏目录
Java多线程-Thread源码解析
Mr.xing的博客
03-10 1361
复杂逻辑下的对象传递，比如监听器的传递，有些时候一个线程中的任务过于复杂，这可能表现为函数调用栈比较深以及代码入口的多样性，在这种情况下，还需要监听器能够贯穿整个线程的执行过程，这时可以采用ThreadLocal，采用ThreadLocal可以让监听器作为线程内的全局对象而存在，在线程内部只要通过get方法就可以获取到监听器。拿到每个线程独有的ThreadLocalMap然后再用ThreadLocal的当前实例，拿到Map中的相应的 Entry，然后就可以拿到相应的值返回出去。
Thread机制源码
lin_henry的博客
08-05 320
1 源码解析 1.1构造方法
深入Java Thread底层源码实现
我的博客
09-14 1102
Thread就是程序中一个线程的执行.JVM允许一个应用中多个线程并发执行 每个线程都有优先级.高优先级线程优先于低优先级线程执行 每个线程都可以(不可以)被标记为守护线程 当线程中的run()方法代码里面又创建了一个新的线程对象时,新创建的线程优先级和父线程优先级一样 当且仅当父线程为守护线程时,新创建的线程才会是守护线程 当JVM启动时,通常会有唯一的一个非守护线程(这一线程用于调用指定类的main()方法) JVM会持续执行线程直到下面某一个情况发生为止
Thread的源码解析
AnNanDu的博客
07-03 1189
1、Thread类实现了Runnable的接口 public class Thread implements Runnable Runnable的源码只有一个抽象的run方法，并被注解@FunctionalInterface定义了函数式接口，它们主要用在Lambda表达式和方法引用，使用Lambda时必须是函数式接口，这就是使用lambda表达式创建线程的方式，简化了代码 new Thread(() -> System.out.println("lambda表达式")).start();.
Thread源码浅析
在风雨中奔跑
10-29 420
一、Thread类的数据结构 class Thread implements Runnable { //... private char name[];//线程的名字 private int priority;//线程的优先级 //... /* Whether or not the thread is a daemon thr
jdk1.8 rt.jar 源码
09-28
Java开发工具包（JDK）是Java编程语言的核心组件，其中包含了运行和开发Java应用程序所需的库和工具。在 JDK 1.8 版本中，`rt.jar` 是一个非常重要的文件，它包含了Java标准版（Java SE）的运行时类库。这个库包含了...
jdk1.6 源码jdk1.6 源码
06-07
4. **多线程**：JDK 1.6支持多线程编程，源码中包括了`Thread`类和`synchronized`关键字的实现，以及线程同步机制如`wait()`, `notify()`, `notifyAll()`。 5. **I/O流**：在`java.io`包中，你可以看到文件读写、...
jdk源码 jdk源码
02-01
Java Development Kit (JDK) 源码是学习和理解Java平台核心机制的关键资源。...通过深入阅读JDK源码，开发者不仅可以增强对Java语言特性的理解，还能提高解决实际问题的能力，这对于成为一名优秀的Java开发者至关重要。
java8源码-jdk8:jdk8源码阅读理解
06-04
jdk8源码的阅读理解 导入idea步骤: 阅读顺序: 大致思路 基本类型的包装类（Character放在最后） String、StringBuffer、StringBuilder、StringJoiner、StringTokenizer（补充正则表达式的知识） CharacterIterator、...
jdkSource:jdk源码阅读分析
03-23
此外，JVM（Java Virtual Machine）的部分虽然不在JDK源码中，但与之相关的类加载器、内存管理、垃圾收集等知识也是JDK源码分析的重要内容。理解JVM的工作原理，对于优化程序性能，避免内存泄漏等问题至关重要。 总...
线程：Thread类源码解析(下)
Jakob_Hu的博客
11-01 226
Thread类源码解析4.Thread APIsleep方法yield方法setPriority方法interrupt方法*Join方法 4.Thread API sleep方法 sleep 方法会使线程休眠指定的时间长度。 休眠的意思是，当前逻辑执行到此不再继续执行，而是等待指定的时间。但在这段时间内，该线程持有的 monitor 锁（锁在以后的笔记中讲解）并不会被放弃。可以认为线程只是工作到一...
java中Thread类的源码_Java源码分析 – Thread线程类源码分析
weixin_28307725的博客
02-28 202
1、继承关系：首先看到Thread类的声明：class Thread implements Runnable {/* Make sure registerNatives is the first thing does. */可知，其实现了Runnable接口，而Runnable接口有一个run()方法，所以Thread也实现了该方法。2、构造函数：找到其无参构造函数：public Thread()...
Thread类源码解析
weixin_42340366的博客
10-18 207
public class Thread implements Runnable { /* Make sure registerNatives is the first thing <clinit> does. */ private static native void registerNatives(); static { registerNat...
Thread线程源码解析
Lisam Blog
09-30 485
1 首先我们来看Thread类的大致注释翻译如下：     Thread是程序执行中的一个线程，JVM允许程序有多个线程并发执行。     每个线程都有一个优先级，线程优先级高的先执行，每个线程都可能被标记为守护进程。在程序运行时，一个线程创建了新的Thread对象，会为新的线程对象设置优先级，其优先级会等于创建他的线程的优先级。     当JVM启动时，会创建一个非守护线程(被叫做"ma...
Thread之锁的底层原理
xiewz1112的博客
09-10 612
java中锁比synchronized更具有灵活性，其底层原理简单说就是，集合了AbstractQueuedSynchronizer同步器。同步器作为上层的锁（或同步组件）和底层同步状态控制技术之间的桥梁，主要采用了同步队列、同步状态、CAS原子操作方法，实现了同步状态管理、线程排队、等待与唤醒等底层操作。同步器与锁隔离了现实者和使用者的关注点。 模型： class exampleLock...
Thread类源码剖析
勇往直前的专栏
02-02 1005
目录 1.引子 2.JVM线程状态 3.Thread常用方法 4.拓展点     一、引子 说来也有些汗颜，搞了几年java，忽然发现竟然没拜读过java.lang.Thread类源码，这次特地拿出来晒一晒。本文将剖析Thread类源码（本文后面源码全部默认JDK8），并讲解一些重要的拓展点。希望对大家能有一些帮助。 本文讲解主干全部出自源码和注释，保证了权威性。（注意：网上，某...
并发编程(一)-Thread 源码分析
最新发布
流星1688
03-19 644
Thread源码分析，通过注释+流程图，分析源码过程
2021-07-20
weixin_43419545的博客
07-20 145
Thread的基本方法构造方法 构造方法 Thread() 分配一个新的 Thread对象。 Thread(Runnable target) 分配一个新的 Thread对象。 Thread(Runnable target, String name) 分配一个新的 Thread对象。 Thread(String name) 分配一个新的 Thread对象。 Thread(ThreadGroup group, Runnable target) 分配一个新的 Thread对象。 Th
ThreadLocal与InheritableThreadLocal实现原理
xj_524256192的博客
11-11 156
ThreadLocal实现原理 《Java并发编程之美》的介绍：ThreadLocal是JDK包提供的，它提供了线程本地变量，也就是如果你创建了一个ThreadLocal变量，那么访问这个变量的每个线程都会有这个变量的一个本地副本。当多个线程操作这个变量时，实际操作的是自己本地内存里面的变量，从而避免了线程安全问题。创建一个ThreadLocal变量后，每个线程都会复制一个变量到自己的本地内存。 set方法： public void set(T value) { //获取当前线程 Thread t
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

至真源

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值