曦曦粉丝会视频链接: https://v.qq.com/x/page/o3010zxz73y.html

周末闲看微信时，看到了上面这个视频，一个 4 岁的小孩，面对一群大人提出的人问题，回答得头头是道，燃起了我的好奇心：一个还没上学的小孩竟然知道这么多东西，是怎么学会的？而且看起来小孩看起来很快乐，很享受这个过程，是不是在学习的时候也是这种愉快的状态？小孩的父母是什么人，怎么培养小孩的？。。。带着这些问题，开始 Google 搜索，刚开始找到了另外的 2 个视频。
一个是这位名叫曦曦的小孩在 1 岁 11 个月的时候就会背圆周率小数点后 50 位。

2岁背圆周率视频链接: https://youtu.be/8kH4qmM-dSg

一个也是 4 岁时的曦曦，在众人面前把几何学的公式都背出来了，连椭圆这种初高中才学的也都会，先不评论他是否会理解这些知识，能记住这些我觉得对一个 4 岁的小孩来说已经很棒了。这视频能看到小孩父亲一直在引导他，给他一些提示，从这个细节可以看出这些都是老爸教的。接下来我的关注点在他老爸身上，搜他。

4岁几何学视频链接: https://youtu.be/eBEjoXAyOeg

陈光。标签是亚洲记忆大师、国际记忆大师。要是以往，我会揪住这些标签，看是不是很有水分，但是现在不会了，只想了解到我关注的地方。通过简单的搜索，发现这个陈光老师研究和传播记忆学的原因：他妹妹自杀了，因为陈光和他哥哥、姐姐成绩太优秀了，他妹妹成绩不好，最终压力太大自杀。

看到了记忆这块，以前没关注这个，引起了我的好奇心，接着搜了他的一些教程，看到“吸英大法”，这套教程是教学生背单词的，总共有 3 集，3 个小时的课程。想想花 3 个小时了解一下是有多么玄的记忆学，学了没用没关系，有用那就赚了，周末 2 天用这套视频下饭，带着疑惑：难道小孩知道的知识也是用这个记忆学方法学的？

3 个视频链接如下：

视频 1：http://player.youku.com/embed/XMjc4OTUzNDQ=

视频 2: http://player.youku.com/embed/XMjc4OTQ4NjA=

视频 3：http://player.youku.com/embed/XMjc4OTUxODA=

把 3 个视频看下来，给我最大的体验就是，这东西还真有点用。可能以前我接触的东西比较少，学习也没啥方法技巧，所以看着视频，至少现在几天过去了，我还记得视频里面记忆的东西，比如视频开头的工作分为几种：上班族、自由职业、专家、投资、企业家。再比如：鬼火、婴儿、中央山脉、馒头、西瓜、马桶、007、淋巴球、棺材、衣领、筷子、蛋、雨伞、椅子、鹦鹉、女王、天平、尾巴、救火车、邻居，这 20 个毫无联系的词，也能默写出来，其实教程里面把这 20 个词给加了逻辑，所以就很容易记。

主要讲了有如下几点：

7 ± 2 原理

人的脑子有天然的缺陷，一次无法记住太长的东西，举个例子，手机号码 11 位，我们常见的记法是 344，没有人是 11 个数字直接记的吧？有的话那只能说牛逼！！！这个原理就是要把记住的东西进行分割，太长的就分割成几个短的来记。

倒着记忆

我发现视频有个小细节，就是不管拆分多少个来记，陈光老师都会要求倒过来背一次，我也挺好奇的，结合另外一个视频，讲解了突触的概念，我就明白了为什么要倒着记，就是激发大脑的逻辑，训练思维。

记单词

视频里面讲的记单词的步骤：

1. 中文磁化
2. 7 ± 2 原理
3. 英文磁化（能用相近的英文单词则用英文单词）
4. 加入逻辑

举个例子：
我们要背单词：hypertension

1. 中文磁化：理解高血压是一种病。
2. 7 ± 2 原理：12 个字母，超过 7 个，所以需要分割。
3. 英文磁化：hyper（中文发音“害怕”） + ten（中文发音“天”） + sion（中文发音“旋”） 。
4. 加入逻辑：害怕天旋的人有高血压。

是不是一下子就把这个单词记住了？

艾宾浩斯遗忘曲线

遗忘曲线也是一个大脑缺陷，在学习完后，因为我们记住的是短时记忆，会有一个遗忘曲线，时间越久记忆量越少，只有在一段时间后重新回忆起来，经过不断的加强，才会形成永久记忆，所以陈光老师推荐每天睡觉前和起床后进行一次回忆来加强记忆。下图记录了遗忘曲线的一些数据统计。

闲谈

最近网络好像对第一个视频里面的曦曦小孩反映很大，说他爸爸为了利益，拿自己小孩去做营销啥的，有的说小孩很惨，这么小就被塞进那么多知识，没有了童年的快乐。。。其实我想，这老爸也挺难的，假如自己的小孩和普通人一样，那别人就会说，你的记忆方法那么好，为啥你的小孩和别人一样；现在小孩记忆学得好，人家又说小孩真惨。我是这么觉得的，从 Facebook 陈光老师发的一些小孩日常学习交流的视频，看得出小孩是非常喜欢那种学习的状态的，小孩享受那种过程，这是一个父亲和小孩相处的一种方式。每一个人都是第一次当父母，都有自己养育孩子的方法，没有对错，自己觉得合适就好，不同的养育方式会带来不同的人生。

有兴趣的朋友可以去看那 3 集《吸英大法》，看对自己是不是有用。

推荐阅读

写了那么多年 Java 代码，终于 debug 到 JVM 了

全网最新最简单的 openjdk13 代码编译

了解Java线程优先级，更要知道对应操作系统的优先级，不然会踩坑

线程最最基础的知识

老板叫你别阻塞了

吃个快餐都能学到串行、并行、并发

泡一杯茶，学一学同异步

进程知多少？

设计模式看了又忘，忘了又看？

后台回复『设计模式』可以获取《一故事一设计模式》电子书

觉得文章有用帮忙转发&点赞，多谢朋友们！

Java 多线程系列第 7 篇。

这篇我们来讲讲线程的另一个特性：守护线程 or 用户线程？

我们先来看看 Thread.setDaemon() 方法的注释，如下所示。

1. Marks this thread as either a daemon thread or a user thread.
2. The Java Virtual Machine exits when the only threads running are all daemon threads.
3. This method must be invoked before the thread is started.

里面提到了 3 点信息，一一来做下解释：

官方特性

1. 用户线程 or 守护线程？

把 Java 线程分成 2 类，一类是用户线程，也就是我们创建线程时，默认的一类线程，属性 daemon = false；另一类是守护线程，当我们设置 daemon = true 时，就是这类线程。

两者的一般关系是：用户线程就是运行在前台的线程，守护线程就是运行在后台的线程，一般情况下，守护线程是为用户线程提供一些服务。比如在 Java 中，我们常说的 GC 内存回收线程就是守护线程。

2. JVM 与用户线程共存亡

上面第二点翻译过来是：当所有用户线程都执行完，只存在守护线程在运行时，JVM 就退出。看了网上资料以及一些书籍，全都有这句话，但是也都只是有这句话，没有讲明是为啥，好像这句话就成了定理，不需要证明的样子。既然咱最近搭建了 JVM Debug 环境，那就得来查个究竟。（查得好辛苦，花了很久的时间才查出来）

我们看到 JVM 源码 thread.cpp 文件，这里是实现线程的代码。我们通过上面那句话，说明是有一个地方监测着当前非守护线程的数量，不然怎么知道现在只剩下守护线程呢？很有可能是在移除线程的方法里面，跟着这个思路，我们看看该文件的 remove() 方法。代码如下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

/**
 * 移除线程 p
 */
void Threads::remove(JavaThread* p, bool is_daemon) {

  // Reclaim the ObjectMonitors from the omInUseList and omFreeList of the moribund thread.
  ObjectSynchronizer::omFlush(p);

  /**
   * 创建一个监控锁对象 ml
   */
  // Extra scope needed for Thread_lock, so we can check
  // that we do not remove thread without safepoint code notice
  { MonitorLocker ml(Threads_lock);

    assert(ThreadsSMRSupport::get_java_thread_list()->includes(p), "p must be present");

    // Maintain fast thread list
    ThreadsSMRSupport::remove_thread(p);

    // 当前线程数减 1
    _number_of_threads--;
    if (!is_daemon) {
        /**
         * 非守护线程数量减 1
         */
      _number_of_non_daemon_threads--;

      /**
       * 当非守护线程数量为 1 时，唤醒在 destroy_vm() 方法等待的线程
       */
      // Only one thread left, do a notify on the Threads_lock so a thread waiting
      // on destroy_vm will wake up.
      if (number_of_non_daemon_threads() == 1) {
        ml.notify_all();
      }
    }
    /**
     * 移除掉线程
     */
    ThreadService::remove_thread(p, is_daemon);

    // Make sure that safepoint code disregard this thread. This is needed since
    // the thread might mess around with locks after this point. This can cause it
    // to do callbacks into the safepoint code. However, the safepoint code is not aware
    // of this thread since it is removed from the queue.
    p->set_terminated_value();
  } // unlock Threads_lock

  // Since Events::log uses a lock, we grab it outside the Threads_lock
  Events::log(p, "Thread exited: " INTPTR_FORMAT, p2i(p));
}

我在里面加了一些注释，可以发现，果然是我们想的那样，里面有记录着非守护线程的数量，而且当非守护线程为 1 时，就会唤醒在 destory_vm() 方法里面等待的线程，我们确认已经找到 JVM 在非守护线程数为 1 时会触发唤醒监控 JVM 退出的线程代码。紧接着我们看看 destory_vm() 代码，同样是在 thread.cpp 文件下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

bool Threads::destroy_vm() {
  JavaThread* thread = JavaThread::current();

#ifdef ASSERT
  _vm_complete = false;
#endif
  /**
   * 等待自己是最后一个非守护线程条件
   */
  // Wait until we are the last non-daemon thread to execute
  { MonitorLocker nu(Threads_lock);
    while (Threads::number_of_non_daemon_threads() > 1)
        /**
         * 非守护线程数大于 1，则一直等待
         */
      // This wait should make safepoint checks, wait without a timeout,
      // and wait as a suspend-equivalent condition.
      nu.wait(0, Mutex::_as_suspend_equivalent_flag);
  }

  /**
   * 下面代码是关闭 VM 的逻辑
   */
  EventShutdown e;
  if (e.should_commit()) {
    e.set_reason("No remaining non-daemon Java threads");
    e.commit();
  }
  ...... 省略余下代码
}

我们这里看到当非守护线程数量大于 1 时，就一直等待，直到剩下一个非守护线程时，就会在线程执行完后，退出 JVM。这时候又有一个点需要定位，什么时候调用 destroy_vm() 方法呢？还是通过查看代码以及注释，发现是在 main() 方法执行完成后触发的。

在 java.c 文件的 JavaMain() 方法里面，最后执行完调用了 LEAVE() 方法，该方法调用了 (*vm)->DestroyJavaVM(vm); 来触发 JVM 退出，最终调用 destroy_vm() 方法。

1
2
3
4
5
6
7
8
9
10
11

#define LEAVE() \
    do { \
        if ((*vm)->DetachCurrentThread(vm) != JNI_OK) { \
            JLI_ReportErrorMessage(JVM_ERROR2); \
            ret = 1; \
        } \
        if (JNI_TRUE) { \
            (*vm)->DestroyJavaVM(vm); \
            return ret; \
        } \
    } while (JNI_FALSE)

所以我们也知道了，为啥 main 线程可以比子线程先退出？虽然 main 线程退出前调用了 destroy_vm() 方法，但是在 destroy_vm() 方法里面等待着非守护线程执行完，子线程如果是非守护线程，则 JVM 会一直等待，不会立即退出。

我们对这个点总结一下：Java 程序在 main 线程执行退出时，会触发执行 JVM 退出操作，但是 JVM 退出方法 destroy_vm() 会等待所有非守护线程都执行完，里面是用变量 number_of_non_daemon_threads 统计非守护线程的数量，这个变量在新增线程和删除线程时会做增减操作。

另外衍生一点就是：当 JVM 退出时，所有还存在的守护线程会被抛弃，既不会执行 finally 部分代码，也不会执行 stack unwound 操作（也就是也不会 catch 异常）。这个很明显，JVM 都退出了，守护线程自然退出了，当然这是守护线程的一个特性。

3. 是男是女？生下来就注定了

这个比较好理解，就是线程是用户线程还是守护线程，在线程还未启动时就得确定。在调用 start() 方法之前，还只是个对象，没有映射到 JVM 中的线程，这个时候可以修改 daemon 属性，调用 start() 方法之后，JVM 中就有一个线程映射这个线程对象，所以不能做修改了。

其他的特性

1.守护线程属性继承自父线程

这个咱就不用写代码来验证了，直接看 Thread 源代码构造方法里面就可以知道，代码如下所示。

1
2
3
4
5
6
7

private Thread(ThreadGroup g, Runnable target, String name,
               long stackSize, AccessControlContext acc,
               boolean inheritThreadLocals) {
   ...省略一堆代码
    this.daemon = parent.isDaemon();
   ...省略一堆代码
}

2.守护线程优先级比用户线程低

看到很多书籍和资料都这么说，我也很怀疑。所以写了下面代码来测试是不是守护线程优先级比用户线程低？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

public class TestDaemon {
    static AtomicLong daemonTimes = new AtomicLong(0);
    static AtomicLong userTimes = new AtomicLong(0);

    public static void main(String[] args) {
        int count = 2000;
        List<MyThread> threads = new ArrayList<>(count);
        for (int i = 0; i < count; i ++) {
            MyThread userThread = new MyThread();
            userThread.setDaemon(false);
            threads.add(userThread);

            MyThread daemonThread = new MyThread();
            daemonThread.setDaemon(true);
            threads.add(daemonThread);
        }

        for (int i = 0; i < count; i++) {
            threads.get(i).start();
        }

        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("daemon 统计：" + daemonTimes.get());
        System.out.println("user 统计：" + userTimes.get());
        System.out.println("daemon 和 user 相差时间：" + (daemonTimes.get() - userTimes.get()) + "ms");

    }

    static class MyThread extends Thread {
        @Override
        public void run() {
            if (this.isDaemon()) {
                daemonTimes.getAndAdd(System.currentTimeMillis());
            } else {
                userTimes.getAndAdd(System.currentTimeMillis());
            }
        }
    }
}

运行结果如下。

1
2
3
4
5
6
7
8
9

结果1：
daemon 统计：1570785465411405
user 统计：1570785465411570
daemon 和 user 相差时间：-165ms

结果2：
daemon 统计：1570786615081403
user 统计：1570786615081398
daemon 和 user 相差时间：5ms

是不是很惊讶，居然相差无几，但是这个案例我也不能下定义说：守护线程和用户线程优先级是一样的。看了 JVM 代码也没找到守护线程优先级比用户线程低，这个点还是保持怀疑，有了解的朋友可以留言说一些，互相交流学习。

总结

总结一下这篇文章讲解的点，一个是线程被分为 2 种类型，一种是用户线程，另一种是守护线程；如果要把线程设置为守护线程，需要在线程调用start()方法前设置 daemon 属性；还有从 JVM 源码角度分析为什么当用户线程都执行完的时候，JVM 会自动退出。接着讲解了守护线程有继承性，父线程是守护线程，那么子线程默认就是守护线程；另外对一些书籍和资料所说的 守护线程优先级比用户线程低 提出自己的疑问，并希望有了解的朋友能帮忙解答。

如果觉得这篇文章看了有收获，麻烦点个在看，支持一下，原创不易。

推荐阅读

写了那么多年 Java 代码，终于 debug 到 JVM 了

全网最新最简单的 openjdk13 代码编译

了解Java线程优先级，更要知道对应操作系统的优先级，不然会踩坑

线程最最基础的知识

老板叫你别阻塞了

吃个快餐都能学到串行、并行、并发

泡一杯茶，学一学同异步

进程知多少？

设计模式看了又忘，忘了又看？

后台回复『设计模式』可以获取《一故事一设计模式》电子书

觉得文章有用帮忙转发&点赞，多谢朋友们！

继上篇文章 原创 | 全网最新最简单的 openjdk13 代码编译 之后，我们有了自己编译后的 jdk 和 hotspot，如下图所示。接下来就来干一番事情。

搭建调试环境

1.下载 CLion 软件

Jetbrains 是一家非常牛逼的公司，咱 Java 里面用到的 IDEA 功能很强大，这公司也为 C/C++ 提供一个 IDE，名叫 CLion，咱需要下载这个 IDE 来调试 JVM 源码。

2.导入源码

安装完 CLion 之后，咱就可以先导入代码，下面简单记录一下操作步骤。

选择 New CMake Project from Sources。

打开我们下载 OpenJDK13 的目录，我的目录是 /opt/java/openjdk/jdk13。

接下来有弹框点击 Next 就行了，等待导入源码完成（需要几分钟，可以喝杯茶）。

3.启动配置

导完源码后，我们需要配置启动程序，这里有些配置需要重新指定，主要有下面 2 点。

• Executable 修改为咱们编译后的 java 程序。

• Build 需要删除掉。

4.打下断电

我们在 thread.cpp 代码的 Threads::create_vm 方法打下断点。

5.开始 Debug

点击 Debug 按钮，开始调试我们的 JVM 代码。可以看到我们打的断点生效了，如下图所示。

恭喜，我们成功调试 JVM 代码。不过发现了下面这个异常信息，解决它。

6.发现这个异常

按 F9 让程序继续跑，我们发现 Console 出现了下面红框的一行字。

这是 GDB 的异常信息，我们可以通过在我们的用户目录下添加配置来解决这个问题。创建 ~/.gdbinit 文件，添加如下配置。

1
2
3
4
5

handle SIGSEGV nostop noprint pass
handle SIGBUS nostop noprint pass
handle SIGFPE nostop noprint pass
handle SIGPIPE nostop noprint pass
handle SIGILL nostop noprint pass

再运行就不会有这个异常信息了。

调试自己的代码

上面已经调通了我们编译的 JVM 源码，有同学可能想知道，那要调试自己写的代码得怎么操作呢？我们上面已经看到 Debug 到 JVM 源码了，我们自己的代码则可以通过我们编译后的 JDK 来编译，然后在程序执行参数那里指定。下面举个例子。

1.编写 Test 代码

我们编写一个简单的 Hello JVM 程序，代码如下。

1
2
3
4
5
6

public class Test {

    public static void main(String[] args) {
        System.out.println("hello jvm");
    }
}

2.javac 编译

通过我们编译后的 JDK 命令 javac Test.java 来编译。

1

liebrother@liebrother:/opt/java/openjdk/jdk13/build/linux-x86_64-server-release/jdk/bin$ ./javac Test.java

3.配置启动参数

然后在 Clion 程序启动配置那里指定我们的类 Test。

结果就是我们的程序被运行了。

以上就是我们今天要讲的在 JVM 层面上调试我们自己写的程序。

总结

总结一下搭建这套 JVM 环境。搭建过程中其实没有很波折，官方文档写的很清晰（虽然都是英文的），这 2 篇文章也是尽最大的努力，把一些步骤简化，也截图保留下来，一方面给自己回顾的机会，一方面也是给有想要搭建这套环境的朋友们一个捷径。这套环境接下来的定义是：给自己深入了解 JVM 的机会，在遇到某些知识点不清晰，不明白原理的时候，就可以看一看源码，揪出源头的逻辑。

非常建议朋友们搭建这么一套环境，也不要怕 JVM 里面都是 C/C++ 代码，可能刚开始看的时候会很费劲，看多了就习惯了。

推荐阅读

写了那么多年 Java 代码，终于 debug 到 JVM 了

原创 | 全网最新最简单的 openjdk13 代码编译

了解Java线程优先级，更要知道对应操作系统的优先级，不然会踩坑

线程最最基础的知识

老板叫你别阻塞了

吃个快餐都能学到串行、并行、并发

泡一杯茶，学一学同异步

进程知多少？

设计模式看了又忘，忘了又看？

后台回复『设计模式』可以获取《一故事一设计模式》电子书

觉得文章有用帮忙转发&点赞，多谢朋友们！

[TOC]

最近因写文章需要查看 JVM 源码，有时代码逻辑不是很清晰，找半天，趁国庆假期，抽空下载了 OpenJDK13 搭建了 JVM debug 环境，把操作记录写在这篇文章里，让有需要的朋友可以参考，少踩坑。

我是在 Ubuntu 18.04 下编译的，不是在 Windows，建议不在 Windows 下折腾，会遇到比在 Linux 环境下多得多的问题。如果你电脑也是 Windows，可以像我这样，安装个 VMware 虚拟机软件，在里面装个 Ubuntu 系统，在虚拟机里面玩，这 2 个软件在官网下载就行，当然如果懒得去找也可以在我的公众号后台回复: 虚拟机 获取 VMware 软件和 Ubuntu 18.04 镜像。

安装 Ubuntu 虚拟机就不在这篇文章说了，网上有相关的资料。

开始咯

1.下载源码

平时咱用的代码管理工具大多数是 Git，OpenJDK 并不是，而是用 Mercurial 管理工具，所以我们要安装它。通过下面命令安装。

1

sudo apt-get install mercurial

安装完代码管理工具后，我们就可以下载 OpenJDK13 的源码了，使用如下命令即可下载。这个过程根据网络状况，需要的时间不一，我下载花了十来分钟。

1

hg clone http://hg.openjdk.java.net/jdk/jdk13/

嗯，我就是这样干等了十来分钟，因为具体的官方操作文档也在里面，没下载下来无法看，网上也找不到相关的 Ubuntu 18 编译 OpenJDK13 的文章，所以不知道具体要安装哪些依赖。现在你看到这篇文章，可以不用干等着了，接下来步骤 2 和 3 不依赖源代码，可以继续操作。

2.安装编译需要的依赖

这一部分是查看了官方文档，做了总结，官方文档里面是按软件区分的，那样一个命令一个命令敲有点繁琐，就把它整合成一个命令，执行就完了，满足有些朋友想尽快编译完，少些多余的东西。

1

sudo apt-get install libfreetype6-dev libcups2-dev libx11-dev libxext-dev libxrender-dev libxrandr-dev libxtst-dev libxt-dev libasound2-dev libffi-dev autoconf gcc clang libfontconfig1-dev

想了解这些依赖软件是干嘛用的，可以看看官方文档，文档的位置如下图。

3.安装 jdk 12

这个在文档里面称为 Boot JDK，就是编译时需要上一个版本的 JDK 做为基础，一般是使用 N-1 版本，比如编译 OpenJDK8 就使用 JDK7 作为 Boot JDK，我们这里是编译 OpenJDK13，所以使用的是 JDK12。也是执行下面命令就搞定。

1
2
3

sudo add-apt-repository ppa:openjdk-r/ppa
sudo apt-get update
sudo apt-get install openjdk-12-jdk

安装完可以通过 java -version 来验证一下是否成功安装。见到如下结果就妥妥的。

执行完上面步骤，那么恭喜你，现在就可以开始编译了。

4.检查配置

我们安装了上面那么多东西，需要来检查一下是不是已经安装完所需要的软件，通过下面命令来检查。

1

bash configure

如果执行过程中有异常，就根据异常和提示信息，安装所缺的软件就行。如果看到下面的结果，那么再一次恭喜你，所有依赖软件都准备好了。

5.开始编译

最激动人心的时刻到来了，敲入下面的命令，开始编译吧。这个过程大概需要半个小时，耐心等候，可以稍作休息，喝杯 82 年的咖啡。

1

make images

见证奇迹的图片。看到下图说明编译成功啦。

6.验证是否成功

还需要再稳一点，验证编译后的 java 是否可用，通过下面的命令来验证。

1

./build/*/images/jdk/bin/java -version

看下图，出现 "13-internal" 2019-09-17 字样，我们编译出来的 JDK13 可以用啦。

这标题起得不过分吧，上面版本日期是 2019-09-17，还不到一个月，网上相关资料也没，就只有官方文档了（当然也是最好的资料）。跟着步骤走，不会丢，为了验证这句话，还把上面的步骤在我快退休的笔记本上跑了一遍，妥妥的。

回顾

我们这篇文章就讲了编译 OpenJDK13，接下来会再写一篇怎么搭建 Debug JVM 环境，可以关注公众号，期待下一篇。

推荐阅读

了解Java线程优先级，更要知道对应操作系统的优先级，不然会踩坑

线程最最基础的知识

老板叫你别阻塞了

吃个快餐都能学到串行、并行、并发

泡一杯茶，学一学同异步

进程知多少？

设计模式看了又忘，忘了又看？

后台回复『设计模式』可以获取《一故事一设计模式》电子书

觉得文章有用帮忙转发&点赞，多谢朋友们！

Java 多线程系列第 6 篇。

这篇我们来看看 Java 线程的优先级。

Java 线程优先级

Thread 类中，使用如下属性来代表优先级。

1

private int priority;

我们可以通过 setPriority(int newPriority) 来设置新的优先级，通过 getPriority() 来获取线程的优先级。

有些资料通过下面的例子就得出了一个结论：Java 线程默认优先级是 5。

1
2
3
4
5
6

public static void main(String[] args) {
    Thread thread = new Thread();
    System.out.println(thread.getPriority());
}

// 打印结果：5

其实这是大错特错的，只是看到了表面，看看下面的例子，我们把当前线程的优先级改为 4，发现子线程 thread 的优先级也是 4。

1
2
3
4
5
6
7

public static void main(String[] args) {
    Thread.currentThread().setPriority(4);
    Thread thread = new Thread();
    System.out.println(thread.getPriority());
}

// 打印结果：4

这啪啪啪打脸了，如果是线程默认优先级是 5，我们新创建的 thread 线程，没设置优先级，理应是 5，但实际是 4。我们看看 Thread 初始化 priority 的源代码。

1
2

Thread parent = currentThread();
this.priority = parent.getPriority();

原来，线程默认的优先级是继承父线程的优先级，上面例子我们把父线程的优先级设置为 4，所以导致子线程的优先级也变成 4。

严谨一点说，子线程默认优先级和父线程一样，Java 主线程默认的优先级是 5。

Java 中定义了 3 种优先级，分别是最低优先级（1）、正常优先级（5）、最高优先级（10），代码如下所示。Java 优先级范围是 [1, 10]，设置其他数字的优先级都会抛出 IllegalArgumentException 异常。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

/**
 * The minimum priority that a thread can have.
 */
public final static int MIN_PRIORITY = 1;

/**
 * The default priority that is assigned to a thread.
 */
public final static int NORM_PRIORITY = 5;

/**
 * The maximum priority that a thread can have.
 */
public final static int MAX_PRIORITY = 10;

接下来说说线程优先级的作用。先看下面代码，代码逻辑是创建了 3000 个线程，分别是： 1000 个优先级为 1 的线程， 1000 个优先级为 5 的线程，1000 个优先级为 10 的线程。用 minTimes 来记录 1000 个 MIN_PRIORITY 线程运行时时间戳之和，用 normTimes 来记录 1000 个 NORM_PRIORITY 线程运行时时间戳之和，用 maxTimes 来记录 1000 个 MAX_PRIORITY 线程运行时时间戳之和。通过统计每个优先级的运行的时间戳之和，值越小代表的就是越优先执行。我们运行看看。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

public class TestPriority {
    static AtomicLong minTimes = new AtomicLong(0);
    static AtomicLong normTimes = new AtomicLong(0);
    static AtomicLong maxTimes = new AtomicLong(0);

    public static void main(String[] args) {
        List<MyThread> minThreadList = new ArrayList<>();
        List<MyThread> normThreadList = new ArrayList<>();
        List<MyThread> maxThreadList = new ArrayList<>();

        int count = 1000;
        for (int i = 0; i < count; i++) {
            MyThread myThread = new MyThread("min----" + i);
            myThread.setPriority(Thread.MIN_PRIORITY);
            minThreadList.add(myThread);
        }
        for (int i = 0; i < count; i++) {
            MyThread myThread = new MyThread("norm---" + i);
            myThread.setPriority(Thread.NORM_PRIORITY);
            normThreadList.add(myThread);
        }
        for (int i = 0; i < count; i++) {
            MyThread myThread = new MyThread("max----" + i);
            myThread.setPriority(Thread.MAX_PRIORITY);
            maxThreadList.add(myThread);
        }

        for (int i = 0; i < count; i++) {
            maxThreadList.get(i).start();
            normThreadList.get(i).start();
            minThreadList.get(i).start();
        }

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("maxPriority 统计：" + maxTimes.get());
        System.out.println("normPriority 统计：" + normTimes.get());
        System.out.println("minPriority 统计：" + minTimes.get());
        System.out.println("普通优先级与最高优先级相差时间：" + (normTimes.get() - maxTimes.get()) + "ms");
        System.out.println("最低优先级与普通优先级相差时间：" + (minTimes.get() - normTimes.get()) + "ms");

    }

    static class MyThread extends Thread {

        public MyThread(String name) {
            super(name);
        }

        @Override
        public void run() {
            System.out.println(this.getName() + " priority: " + this.getPriority());
            switch (this.getPriority()) {
                case Thread.MAX_PRIORITY :
                    maxTimes.getAndAdd(System.currentTimeMillis());
                    break;
                case Thread.NORM_PRIORITY :
                    normTimes.getAndAdd(System.currentTimeMillis());
                    break;
                case Thread.MIN_PRIORITY :
                    minTimes.getAndAdd(System.currentTimeMillis());
                    break;
                default:
                    break;
            }
        }
    }
}

执行结果如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 第一部分
max----0 priority: 10
norm---0 priority: 5
max----1 priority: 10
max----2 priority: 10
norm---2 priority: 5
min----4 priority: 1
.......
max----899 priority: 10
min----912 priority: 1
min----847 priority: 5
min----883 priority: 1

# 第二部分
maxPriority 统计：1568986695523243
normPriority 统计：1568986695526080
minPriority 统计：1568986695545414
普通优先级与最高优先级相差时间：2837ms
最低优先级与普通优先级相差时间：19334ms

我们一起来分析一下结果。先看看第一部分，最开始执行的线程高优先级、普通优先级、低优先级都有，最后执行的线程也都有各个优先级的，这说明了：优先级高的线程不代表一定比优先级低的线程优先执行。也可以换另一种说法：代码执行顺序跟线程的优先级无关。看看第二部分的结果，我们可以发现最高优先级的 1000 个线程执行时间戳之和最小，而最低优先级的 1000 个线程执行时间戳之和最大，因此可以得知：一批高优先级的线程会比一批低优先级的线程优先执行，即高优先级的线程大概率比低优先的线程优先获得 CPU 资源。

各操作系统中真有 10 个线程等级么？

Java 作为跨平台语言，线程有 10 个等级，但是映射到不同操作系统的线程优先级值不一样。接下来教大家怎么在 OpenJDK 源码中查各个操作系统中线程优先级映射的值。

1. 看到 Thread 源代码，设置线程优先级最终调用了本地方法 setPriority0()；

1

private native void setPriority0(int newPriority);

1. 接着我们在 OpenJDK 的 Thread.c 代码中找到 setPriority0() 对应的方法 JVM_SetThreadPriority；

1
2
3
4
5

static JNINativeMethod methods[] = {
    ...
    {"setPriority0",     "(I)V",       (void *)&JVM_SetThreadPriority},
    ...
};

1. 我们根据 JVM_SetThreadPriority 找到 jvm.cpp 中对应的代码段；

1
2
3
4
5
6
7
8
9
10
11

JVM_ENTRY(void, JVM_SetThreadPriority(JNIEnv* env, jobject jthread, jint prio))
  JVMWrapper("JVM_SetThreadPriority");
  // Ensure that the C++ Thread and OSThread structures aren't freed before we operate
  MutexLocker ml(Threads_lock);
  oop java_thread = JNIHandles::resolve_non_null(jthread);
  java_lang_Thread::set_priority(java_thread, (ThreadPriority)prio);
  JavaThread* thr = java_lang_Thread::thread(java_thread);
  if (thr != NULL) {                  // Thread not yet started; priority pushed down when it is
    Thread::set_priority(thr, (ThreadPriority)prio);
  }
JVM_END

1. 根据第 3 步中的代码，我们可以发现关键是 java_lang_Thread::set_Priority() 这段代码，继续找 thread.cpp 代码中的 set_Priority() 方法；

1
2
3
4
5
6

void Thread::set_priority(Thread* thread, ThreadPriority priority) {
  trace("set priority", thread);
  debug_only(check_for_dangling_thread_pointer(thread);)
  // Can return an error!
  (void)os::set_priority(thread, priority);
}

1. 发现上面代码最终调用的是 os::set_priority()，接着继续找出 os.cpp 的 set_priority() 方法；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

OSReturn os::set_priority(Thread* thread, ThreadPriority p) {
#ifdef ASSERT
  if (!(!thread->is_Java_thread() ||
         Thread::current() == thread  ||
         Threads_lock->owned_by_self()
         || thread->is_Compiler_thread()
        )) {
    assert(false, "possibility of dangling Thread pointer");
  }
#endif

  if (p >= MinPriority && p <= MaxPriority) {
    int priority = java_to_os_priority[p];
    return set_native_priority(thread, priority);
  } else {
    assert(false, "Should not happen");
    return OS_ERR;
  }
}

1. 终于发现了最终转换为各操作系统的优先级代码 java_to_os_priority[p]，接下来就是找各个操作系统下的该数组的值。比如下面是 Linux 系统的优先级值。

int os::java_to_os_priority[CriticalPriority + 1] = {
  19,              // 0 Entry should never be used

   4,              // 1 MinPriority
   3,              // 2
   2,              // 3

   1,              // 4
   0,              // 5 NormPriority
  -1,              // 6

  -2,              // 7
  -3,              // 8
  -4,              // 9 NearMaxPriority

  -5,              // 10 MaxPriority

  -5               // 11 CriticalPriority
};

好了，大家应该知道怎么找出 Java 线程优先级 [1,10] 一一对应各个操作系统中的优先级值。下面给大家统计一下。

Windows 系统的在 OpenJDK 源码中只找到上面的常量，值是通过微软提供的函数接口文档查到的，链接在这：setthreadpriority

我们从这个表格中也可以发现一些问题，即使我们在 Java 代码中设置了比较高的优先级，其实映射到操作系统的线程里面，并不一定比设置了低优先级的线程高，很有可能是相同的优先级。看看 Solaris 操作系统 这个极端的例子，优先级 5 到 10 映射的是相同的线程等级。

回头想想上面的例子为什么 3000 个线程，MAX_PRIORITY 优先级的 1000 个线程会优先执行呢？因为我们的 3 个优先级分别映射到 Windows 操作系统线程的 3 个不同的等级，所以才会生效。假设将 1、5、10 改成 5、6、7，运行结果那就不大一样了。

最后记住：切莫把线程优先级当做银弹，优先级高的线程不一定比优先级低的线程优先执行。

这篇线程优先级文章也告段落了，朋友们看完觉得有用麻烦帮点个在看，推荐给身边朋友看看，原创不易。

推荐阅读

了解Java线程优先级，更要知道对应操作系统的优先级，不然会踩坑

线程最最基础的知识

老板叫你别阻塞了

吃个快餐都能学到串行、并行、并发

泡一杯茶，学一学同异步

进程知多少？

设计模式看了又忘，忘了又看？

后台回复『设计模式』可以获取《一故事一设计模式》电子书

觉得文章有用帮忙转发&点赞，多谢朋友们！