JVM源码剖析之线程的创建过程

这篇具有很好参考价值的文章主要介绍了JVM源码剖析之线程的创建过程。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

说在前面:

对于Java线程的创建这个话题,似乎已经被"八股文"带偏~ 大部分Java程序员从"八股文"得知创建Java线程有N种方式,比如new Thread、new Runnable、Callable、线程池等等~ 而笔者写下这篇文章的目的是让大家从JVM源码的层面知道创建一个Java线程的方式。

版本信息:
jdk版本:jdk8u40

源码剖析:

public
class Thread implements Runnable {}

从Thread类的继承关系来看,Thread类实现Runnable接口,不少读者可能不明白为什么需要实现Runnable接口,也不明白Thread和Runnable之间的关系,那么笔者不妨以自己见解解释一番~

Thread:Java层面开发者使用的类,开发者可以使用它创建、启动、关闭线程等等操作

Runnable:一个函数式接口,无返回值、无入参,用于回调,其中编写开发者的回调逻辑(逻辑入口)

Callable:一个函数式接口,有返回值、无入参,用于回调,其中编写开发者的回调逻辑(逻辑入口)

所以Thread和Runnable之间的关系一目了然,一个是Java线程的API集合,一个是定义了逻辑入口的接口

为什么Thread需要实现Runnable,因为当线程启动后,Thread需要帮开发者自动执行线程执行体,所以需要一个执行入口方法,刚好Runnable接口就提供了此入口~

接下来看一下Thread的构造方法。

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

    private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize) {
        init(g, target, name, stackSize, null, true);
    }

    private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc,
                      boolean inheritThreadLocals) {
        if (name == null) {
            throw new NullPointerException("name cannot be null");
        }

        this.name = name;

        Thread parent = currentThread();
        SecurityManager security = System.getSecurityManager();
        if (g == null) {

            if (security != null) {
                g = security.getThreadGroup();
            }
            if (g == null) {
                g = parent.getThreadGroup();
            }
        }

        g.checkAccess();

        if (security != null) {
            if (isCCLOverridden(getClass())) {
                security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
            }
        }

        g.addUnstarted();

        this.group = g;
        this.daemon = parent.isDaemon();
        this.priority = parent.getPriority();
        if (security == null || isCCLOverridden(parent.getClass()))
            this.contextClassLoader = parent.getContextClassLoader();
        else
            this.contextClassLoader = parent.contextClassLoader;
        this.inheritedAccessControlContext =
                acc != null ? acc : AccessController.getContext();
        this.target = target;
        setPriority(priority);
        if (inheritThreadLocals && parent.inheritableThreadLocals != null)
            this.inheritableThreadLocals =
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);

        this.stackSize = stackSize;
        tid = nextThreadID();
    }

构造方法虽然比较长,但是都是对当前线程的属性赋值,并没有其他任何操作,所以笔者连注释都没有写。

写到这里,我们需要理解一个点,Java是没有能力创建底层的线程,这个需要交给JVM来创建,而这里new Thread创建的仅仅是Java层面表示的线程对象~

而JVM来创建线程,所以需要Java层面调用native方法,所以我们看到Thread中start方法。

public synchronized void start() {
		// 此线程的状态如果不是创建状态就直接抛出非法逻辑异常。
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        // 添加到对应的线程组中。
        group.add(this);

        boolean started = false;
        try {
        	// Native方法,此方法会创建底层的线程,并且启动线程,并且执行线程的执行体(Runnable的run方法)
            start0();
            started = true;		// 正常启动完毕。
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {

            }
        }
    }

private native void start0();

start方法会去底层创建线程,并且启动线程,执行线程的执行体 ,所以需要看到start0这个native方法的实现,所以下面是C/C++的代码~

{"start0",           "()V",        (void *)&JVM_StartThread}

JVM_ENTRY(void, JVM_StartThread(JNIEnv* env, jobject jthread))
  JVMWrapper("JVM_StartThread");
  JavaThread *native_thread = NULL;

  bool throw_illegal_thread_state = false;

  {
    MutexLocker mu(Threads_lock);

    // 获取到Java开发者设置的栈大小,这个参数一般不会设置
    jlong size =
             java_lang_Thread::stackSize(JNIHandles::resolve_non_null(jthread));

    size_t sz = size > 0 ? (size_t) size : 0;

    // 创建底层的线程。
    // 当创建好线程后,会回调thread_entry此方法。
    native_thread = new JavaThread(&thread_entry, sz);

    if (native_thread->osthread() != NULL) {
      // 初始化线程,比如是否是守护线程,线程优先级。以及线程数量的统计。
      native_thread->prepare(jthread);
    }
  }

  // 设置成运行中状态
  Thread::start(native_thread);

JVM_END

因为JVM是c/c++编写,而c++是有面向对象的思想存在,所以在new JavaThread中,会执行构造方法,我们看到构造方法。

JavaThread::JavaThread(ThreadFunction entry_point, size_t stack_sz) :
  Thread()	// 调用父类构造方法
{
	// 初始化参数
  initialize();
  _jni_attach_state = _not_attaching_via_jni;
  // 设置执行入口,当底层线程创建好以后,会去回调此方法
  set_entry_point(entry_point);		

  // 设置此线程的类型,当前线程是java_thread类型
  os::ThreadType thr_type = os::java_thread;
  thr_type = entry_point == &compiler_thread_entry ? os::compiler_thread :
                                                     os::java_thread;
  // 真正的线程只有操作系统才有权利去创建,所以这里调用操作系统类库去创建。
  os::create_thread(this, thr_type, stack_sz);
  _safepoint_visible = false;

}

bool os::create_thread(Thread* thread, ThreadType thr_type, size_t stack_size) {
  assert(thread->osthread() == NULL, "caller responsible");

  OSThread* osthread = new OSThread(NULL, NULL);

  osthread->set_thread_type(thr_type);

  osthread->set_state(ALLOCATED);

  thread->set_osthread(osthread);

  pthread_attr_t attr;
  pthread_attr_init(&attr);
  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

 
 	…………	// 省略一部分设置参数代码

  // glibc guard page
  pthread_attr_setguardsize(&attr, os::Linux::default_guard_size(thr_type));

  ThreadState state;

  {

    pthread_t tid;
    // java_start 作为统一的入口,后续再根据thread类型做分发(多态)。
    int ret = pthread_create(&tid, &attr, (void* (*)(void*)) java_start, thread);

    pthread_attr_destroy(&attr);

    osthread->set_pthread_id(tid);

    // Wait until child thread is either initialized or aborted
    {
      Monitor* sync_with_child = osthread->startThread_lock();
      MutexLockerEx ml(sync_with_child, Mutex::_no_safepoint_check_flag);
      while ((state = osthread->get_state()) == ALLOCATED) {
        sync_with_child->wait(Mutex::_no_safepoint_check_flag);
      }
    }

    if (lock) {
      os::Linux::createThread_lock()->unlock();
    }
  }

  return true;
}

因为JVM是帮Java开发者实现了跨平台机制,所以需要适配所有OS平台,而我们只关心Linux操作系统,而Linux操作系统使用的是POSIX的线程标准,实现者肯定是Glibc类库,实现就是PThread线程库,而这里也是调用了pthread_create库函数创建了底层的线程(这里不懂没关系,只需要明白会去操作系统创建线程),并且设置线程的执行入口是java_start方法。

// pthread线程回调执行点。
static void *java_start(Thread *thread) {
  
  …………  // 省略大部分的设置参数和状态值的代码,方便观看核心源码

  // 这里是区分JVM层面抽象的不同线程的不同执行点(多态)
  // 而这里thread对象是JavaThread
  thread->run();

  return 0;
}

void JavaThread::run() {
  
  ………… // 省略大部分的设置参数和状态值的代码,方便观看核心源码

  // 执行设置的入口
  thread_main_inner();
}

这里是pthread线程启动后回调的方法,这里会回调JavaThread的thread_main_inner方法。这里如果能看懂C++的读者会发现,这里使用多态思想非常完美~

void JavaThread::thread_main_inner() {

	// 不存在异常
  if (!this->has_pending_exception() &&
      !java_lang_Thread::is_stillborn(this->threadObj())) {

    HandleMark hm(this);
    // 回调设置的入口
    this->entry_point()(this, this);
  }

  DTRACE_THREAD_PROBE(stop, this);

  // 执行到这里代表线程执行结束了,需要做释放工作。
  this->exit(false);
  delete this;
}

 经过一系列的回调,最终来到thread_entry方法。

static void thread_entry(JavaThread* thread, TRAPS) {
  HandleMark hm(THREAD);
  Handle obj(THREAD, thread->threadObj());
  JavaValue result(T_VOID);
  JavaCalls::call_virtual(&result,
                          obj,
                          KlassHandle(THREAD, SystemDictionary::Thread_klass()),
                          vmSymbols::run_method_name(),
                          vmSymbols::void_method_signature(),
                          THREAD);
}

这里非常的简单,在JVM层面调用Java的方法,而这里调用的就是Thread类中run方法(也即调用Runnable接口的run方法)

@Override
public void run() {
    // target参数往往是开发者传入的Runnable接口的实现类。
    if (target != null) {
        target.run();        // 调用开发者的逻辑
    }
}

上面的流程对于不懂JVM源码和不懂C++语言的读者来说非常吃力,甚至看不懂,这也很正常,源码层面是这样。但是读者会给你们做一个总结:

  1. 在Java层面调用Thread类的start方法
  2. start方法是一个native方法,会在c++层面创建JavaThread对象(因为c++也是面向对象)
  3. 在JavaThread的构造方法中会去创建OsThread对象(因为JVM是跨平台,存在很多个操作系统平台,所以需要一个OsThread做高度抽象)
  4. 在Linux操作系统平台中会去创建pthread线程(此线程可以理解为就是操作系统层面的线程)
  5. 创建完pthread线程后会经过一层一层的回调方法,最终回调thread_entry方法
  6. thread_entry方法中,会从JVM层面调用Java层面的方法,而调用的方法是Thread类中run方法,而Thread类是实现Runnable接口,所以也证明了文章开头说的Runnable 接口是作为一个执行入口
  7. 在Thread的run方法中,会去执行用户传入的Runnable接口,或者开发者重写了Thread的run方法。总之,这里就是回调开发者的逻辑。
  8. 所以Java的Thread创建入口就只有一个,就是Java的Thread类的start方法。

JVM源码剖析之线程的创建过程,源码解读,Java底层,java,JVM源码,多线程

线程的关系图如上所述。

其实,你会发现,没有什么是中间抽一层不能解决的,每一层有每一层的职责,但是往往抽一层就需要有中间层的表示状态~

总结:

因为是深入到JVM源码层面,所以部分代码很多读者看不懂。但是代码是科学,他并不是神学,要论证真实性,必须要深入到源码层面。文章来源地址https://www.toymoban.com/news/detail-727603.html

到了这里,关于JVM源码剖析之线程的创建过程的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Spring Boot源码解读与原理剖析:深入探索Java开发的奥秘!

    关注+点赞+评论,评论区回复“Spring Boot源码解读与原理剖析:深入探索Java开发的奥秘!” 每篇最多 评论3条 !!采用抽奖助手自动拉取评论区有效评论送书两本, 开奖时间:9月11号 承载着作者的厚望,掘金爆火小册同名读物 《Spring Boot源码解读与原理剖析》 正式出书!

    2024年02月10日
    浏览(52)
  • 04-JVM对象创建深度剖析

    上一篇:03-JVM内存模型剖析与优化 对象创建的主要流程: 虚拟机遇到一条new指令时,首先将去检查这个指令的参数是否能在常量池中定位到一个类的符号引用,并且检查这个符号引用代表的类是否已被加载、解析和初始化过。如果没有,那必须先执行相应的类加载过程。 ne

    2024年02月09日
    浏览(39)
  • JVM对象创建与内存分配机制深度剖析

    (1)类加载检查 虚拟机遇到一条new指令时,首先将去检查这个指令的参数是否能在常量池中定位到一个类的符号引用,并且检查这个符号引用代表的类是否已被加载、解析和初始化过。如果没有,那必须先执行相应的类加载过程; 所以所类加载是 懒加载 ; new指令对应到语

    2024年02月13日
    浏览(49)
  • 消失的死锁:从 JSF 线程池满到 JVM 初始化原理剖析

    在一次上线时,按照正常流程上线后,观察了线上报文、接口可用率十分钟以上,未出现异常情况,结果在上线一小时后突然收到jsf线程池耗尽的报警,并且该应用一共有30台机器,只有一台机器出现该问题,迅速下线该机器的jsf接口,恢复线上。然后开始排查问题。 [WARN]

    2024年02月08日
    浏览(38)
  • Java进阶(ConcurrentHashMap)——面试时ConcurrentHashMap常见问题解读 & 结合源码分析 & 多线程CAS比较并交换 初识

    List、Set、HashMap作为Java中常用的集合,需要深入认识其原理和特性。 本篇博客介绍常见的关于Java中线程安全的ConcurrentHashMap集合的面试问题,结合源码分析题目背后的知识点。 关于List的博客文章如下: Java进阶(List)——面试时List常见问题解读 结合源码分析 关于的Set的博

    2024年02月06日
    浏览(61)
  • JVM源码剖析之SymbolTable和StringTable

    很多读者在观看JVM相关的书籍时会看到SymbolTable和StringTable,书中的三言二语介绍的不是很清楚,并且读者的水平有限,导致无法理解SymbolTable和StringTable。所以特意写此篇图文并茂的文章来彻底理解SymbolTable和StringTable这两张表。 版本信息如下: 因为Hotspot是c++构成,所以也存

    2024年02月13日
    浏览(33)
  • 【C++】:STL源码剖析之vector类容器的底层模拟实现

    构造一个空vector size和capacity为0 将_start _finish _endofstorage 都置为空指针即可 传统写法 : 1). 新开辟一块和 v 同样容量的空间,更新 _start, _finish, _endofstorage 2). 将 v 中的数据拷贝到新开辟的空间中 注意 : 不要使用memcpy函数拷贝数据,如果数据是内置类型或浅拷贝的自定义类型

    2024年02月04日
    浏览(53)
  • JVM源码剖析之Thread类中sleep方法

    版本信息: jdk版本:jdk8u40 大部分的Java程序员知道让线程睡眠的方法是Thread.sleep方法,而这个方法是一个native方法,让很多想知道底层如何让线程睡眠的程序员望而却步。所以笔者特意写在这篇文章,带各位读者剖析一下Thread.sleep方法背后的神秘。 话不多说,先从Java层面看

    2024年02月07日
    浏览(45)
  • 01-从JDK源码级别剖析JVM类加载机制

    上一篇:JVM虚拟机调优大全 当我们用java命令运行某个类的main函数启动程序时,首先需要通过类加载器把主类加载到JVM。 通过Java命令执行代码的大体流程如下: 其中loadClass的类加载过程有如下几步: 加载 验证 准备 解析 初始化 使用 卸载 加载:在硬盘上查找并通过IO读入字

    2024年02月09日
    浏览(38)
  • 【.NET源码解读】深入剖析中间件的设计与实现

    .NET本身就是一个基于中间件(middleware)的框架,它通过一系列的中间件组件来处理HTTP请求和响应。在之前的文章《.NET源码解读kestrel服务器及创建HttpContext对象流程》中,已经通过源码介绍了如何将HTTP数据包转换为.NET的HttpContext对象。接下来,让我们深入了解一下.NET是如何

    2024年02月11日
    浏览(43)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包