{"componentChunkName":"component---src-templates-blog-post-js","path":"/blog/2020-05-31-jvm/","result":{"data":{"markdownRemark":{"id":"5e0a022a-c12b-5154-816a-77545536cc67","html":"

\"chemex\"

\n

JVM

\n
\n

并发原理

\n
\n

POSIX Thread

\n

\n

基础 API

\n

jvm C 语言创建线程

\n

os_linux.cpp

\n

pthread_create

\n

java 创建线程

\n
\n

Java 中创建线程只有 new Thread(Runable) 一种方式

\n
\n
public class ThreadHelloWorld {\n    public static void main(String[] args) throws Exception{\n        // Java 线程和 JVM OS 线程不是同一个对象\n        // pthread_create()\n        Thread t1 = new Thread(ThreadHelloWorld::helloWorld);\n        t1.start();// pthread_create()\n        t1.join();// pthread_join()\n        // java 线程 isAlive() == false 时， JVM 线程已经消亡（C++: delete this）\n        System.out.prinf(\"线程状态： %s，线程是否存活：%s\", t1.getState(), t1.isAlive());\n    }\n    private static void helloWorld() {\n        System.out.printf(\"Thread[id; %d] - Hello World!\", Thread.currentTread().getId());\n    }\n}\n
\n

同步 API

\n

互斥（Mutex）

\n
Lock
\n
\n

Java 内存模型(Java Memory Model - JMM)

\n

since jdk 1.5\nDoug Lea

\n

共享变量(Shared Variables)

\n

Java 普通对象存放在 Heap 中。\n对于一个对象来说他的地址是确定的，但是对象中的属性地址是计算出来的。

\n

重排序\nJava 中 String 比较特殊\nJava 不是完全的面向对象语言， Object + 基本类型 + 数组

\n

object 地址 + offsets\nJava 针对对象属性采用相对地址计算真实地址，在 cpu 寄存器做了 cas(compare and set) 操作。

\n

Local variables 线程间是隔离的。

\n

动作(Actionss)

\n

同步区别在于范围

\n

顺序(Order)

\n

程序执行顺序

\n
    \n
  1. 顺序执行
    2. \n
\n

单线程是没有数据竟争的，所有程序会顺序执行。\n数据竞争应该是可以被 jvm 识别的。

\n

hashmap 读的时候是线程安全的。

\n
    \n
  1. 同步顺序
    2. \n
\n

保证程序串行

\n

valotile 保证可见性,写的时候加锁，读的时候 valotile

\n
    \n
  1. Thread.start 方法在 Thread.run 方法之前执行
    2. \n
\n
\n

Thread.start method 有 sychronized 关键字。

\n
\n
    \n
  1. x
    2. \n
\n

final 线程在对象创建之前，不会读到字段在初始化的中间状态。\n对象初始化是安全的

\n
    \n
  1. x
    2. \n
  2. xx
    3. \n
\n

interrupt 修改了一个状态，保证该状态其他线程可见

\n

Feture 通过判断线程的 interrupted 状态来控制业务流程

\n

happens of before

\n

这个跟最终一致性不是同一个思想吗

\n

顺序不重要

\n
    \n
  1. 同一线程，程序顺序
    2. \n
  2. \n

    构造早于销毁之前

    \n
      \n
    1. 构造对象是在用户线程（main/子线程）
      2. \n
    2. Finalizer 操作是 JVM 线程(GC)
      3. \n
    3. 对象的 Heap 中， Heap 对于线程是共享的
      4. \n
    \n
    3. \n
  3. \n

    同步关系>= heapens-before

    \n
      \n
    1. 只关心前后关系，不关心是否串行
      2. \n
    2. ConcurrentSkipListMap
      3. \n
    \n
    4. \n
  4. 传递性 hb(x,y) hb(y,z) -> hb(x,z)
    5. \n
\n

happens-before

\n

lock -> object.wait -> unlock

\n

thread.join() 语义

\n
private static void threadStartAndJoin() throws InterruptedException {\n    Thread t = new Thread(() -> {\n        // action\n    });\n    // main 线程调用线程 t 的 join() 方法\n    // 在 join() 方法返回之前， t 所有的 actions 已执行结束\n    t.join();\n}\n
\n\n

延伸

\n

c 语言来保证\nvolatile

\n

保证顺序，并不易定安全。不同作用域？\n最终一致性

\n

Connection

\n

TRANSACTIONREADCOMMITTED,\n结构性不同，单机 多机器

\n

account = 5

\n

t1 add 5

\n

t2 minus 2

\n

t3 minus 3

\n

t3 -> t1 -> t2\n5 - 3 = 2\n2 + 5 = 7\n7 - 2 = 5\n可见性，最终一致性。\n假如不可见， t3 account = 5 - 3 = 2, t2 account = 5 - 2 = 3\n每次读都是从内存中读的，不是 cpu 中的

\n

锁，串行，\n类似 TRANSACTION_SERIALIZEABLE

\n

执行按照定义的顺序

\n

5 + 5 - 2 - 3 = 5

\n

CAS\nAtomic

\n

内存屏障(Memory Barriers)

\n

jvm orderAccess.hpp

\n

java 几大疑问

\n
    \n
  1. synchronized
    2. \n
  2. \n

    volatile

    \n
      \n
    1. 限制重排
      2. \n
    \n
    3. \n
  3. final and immutability
    4. \n
  4. native
    5. \n
  5. actomic
    6. \n
\n

Java 并发框架（J.U.C）AQS 原理

\n

AbstratQueuedSynchronizer（AQS）原理

\n

Provides a framework for implementing blocking locks and related\nsynchronizers (semaphores, events, etc) that rely on\nfirst-in-first-out (FIFO) wait queues.

\n

java.util.concurrent.locks.AbstractQueuedSynchronizer

\n

双向队列

\n
\n

java debugger: 会锁定所有线程

\n
\n

头线程只有状态

\n

公平锁：严格的 FIFO\n非公平锁：\n线程池中新入队的线程会竞争锁，所以在 acquireQueued 时再次 tryAcquire\n//PS: LockSupport.unpark() 解锁

\n

抛出 InterruptedException 时 interrupted 状态被清除

\n

条件变量（ConditionObject）原理

\n

SUMMARY

\n

JVM 并发实现

\n

java.lang.Thread API

\n

基本操作

\n
创建 - new Thread()
\n

new Thread() 创建一个普通的 Java 对象，不涉及线程启动

\n
启动 - thread.start()
\n

thread.start() 引导线程启动，不一定马上启动（非阻塞），最终会调用 thread.run 方法

\n
Thread.java\n\n// 注册 Native 方法\n/* Make sure registerNatives is the first thing <clinit> does. */\nprivate static native void registerNatives();\nstatic {\n    registerNatives();\n}\n\n/**\n * 线程安全\n */\npublic synchronized void start() {\n    ...\n    group.add(this); // 将当前线程添加到所在 ThreadGroup\n    boolean started = false;\n    try {\n        start0(); // Native 方法\n        started = true;\n    } finally {\n        try {\n            if (!started) {\n                group.threadStartFailed(this);\n            }\n        } catch (Throwable ignore) {\n            /* do nothing. If start0 threw a Throwable then\n                it will be passed up the call stack */\n        }\n    }\n}\n\nprivate native void start0(); // JNI Java 调用 JVM 方法\n
\n

类名： java.lang.Thread\n方法名： java.lang.Thread#start0()\nJNI（C函数）: JVM_StartThread

\n
JNIEXPORT void JNICALL\nJava_java_lang_Thread_registerNatives(JNIEnv *env, jclass cls)\n{\n    (*env)->RegisterNatives(env, cls, methods, ARRAY_LENGTH(methods));\n}\n
\n

Thread.c 方法映射

\n
static JNINativeMethod methods[] = {\n    {\"start0\",           \"()V\",        (vo id *)&JVM_StartThread},\n    {\"stop0\",            \"(\" OBJ \")V\", (void *)&JVM_StopThread},\n    {\"isAlive\",          \"()Z\",        (void *)&JVM_IsThreadAlive},\n    {\"suspend0\",         \"()V\",        (void *)&JVM_SuspendThread},\n    {\"resume0\",          \"()V\",        (void *)&JVM_ResumeThread},\n    {\"setPriority0\",     \"(I)V\",       (void *)&JVM_SetThreadPriority},\n    {\"yield\",            \"()V\",        (void *)&JVM_Yield},\n    {\"sleep\",            \"(J)V\",       (void *)&JVM_Sleep},\n    {\"currentThread\",    \"()\" THD,     (void *)&JVM_CurrentThread},\n    {\"interrupt0\",       \"()V\",        (void *)&JVM_Interrupt},\n    {\"holdsLock\",        \"(\" OBJ \")Z\", (void *)&JVM_HoldsLock},\n    {\"getThreads\",        \"()[\" THD,   (void *)&JVM_GetAllThreads},\n    {\"dumpThreads\",      \"([\" THD \")[[\" STE, (void *)&JVM_DumpThreads},\n    {\"setNativeName\",    \"(\" STR \")V\", (void *)&JVM_SetNativeThreadName},\n};\n
\n

stackSize 修改方式

\n
    \n
  1. Xss 设置 VM 全局配置
    2. \n
  2. Thread 针对性设置
    3. \n
\n
 public Thread(ThreadGroup group, Runnable target, String name,\n                  long stackSize) {\n    init(group, target, name, stackSize);\n}\n
\n

方法签名： java.lang.Thread#start0()\nNative 方法： JVM_StartThread\n实现入口：

\n
JVM_ENTRY(void, JVM_StartThread(JNIEnv* env, jobject jthread))\n...\n  {\n    ...\n\n    // Since JDK 5 the java.lang.Thread threadStatus is used to prevent\n    // re-starting an already started thread, so we should usually find\n    // that the JavaThread is null. However for a JNI attached thread\n    // there is a small window between the Thread object being created\n    // (with its JavaThread set) and the update to its threadStatus, so we\n    // have to check for this\n    if (java_lang_Thread::thread(JNIHandles::resolve_non_null(jthread)) != NULL) {\n      throw_illegal_thread_state = true;\n    } else {\n        jlong size =\n             java_lang_Thread::stackSize(JNIHandles::resolve_non_null(jthread));\n      NOT_LP64(if (size > SIZE_MAX) size = SIZE_MAX;)\n      size_t sz = size > 0 ? (size_t) size : 0;\n      native_thread = new JavaThread(&thread_entry, sz);\n        ...\n    }\n  }\n
\n

native_thread 创建了 JavaThread 类型对象\n&threadentry 即函数指针引用函数 threadentry:

\n
static void thread_entry(JavaThread* thread, TRAPS) {\n  HandleMark hm(THREAD);\n  Handle obj(THREAD, thread->threadObj()); // 1 thread->threadObj() 返回 java 代码创建 java.lang.Thread 对象\n  JavaValue result(T_VOID);\n  JavaCalls::call_virtual(&result,\n                          obj,             \n                          SystemDictionary::Thread_klass(), \n                          vmSymbols::run_method_name(), // 2 java.lang.Thread#run 方法名称\n                          vmSymbols::void_method_signature(), // void 方法签名\n                          THREAD);\n}\n
\n

通过 thread_entry 方法查找 vmSymbols.hpp 模版查找到 Thread 对象的 run() 方法

\n

JavaThread::JavaThread 构造函数

\n
JavaThread::JavaThread(ThreadFunction entry_point, size_t stack_sz) :\n                       Thread() {\n    ...\n    initialize();\n  _jni_attach_state = _not_attaching_via_jni;\n  set_entry_point(entry_point); // 设置 thread_entry 到当前对象\n  // Create the native thread itself.\n  // %note runtime_23\n  os::ThreadType thr_type = os::java_thread;\n  thr_type = entry_point == &compiler_thread_entry ? os::compiler_thread : os::java_thread;\n  os::create_thread(this, thr_type, stack_sz); // 创建操作系统线程\n}\n
\n

第一个构造参数 entrypoint 实际指 threadentry

\n

os::createthread linux 实现（oslinux.cpp）

\n
bool os::create_thread(Thread* thread, ThreadType thr_type,\n                       size_t req_stack_size) {\n ...\n  // Allocate the OSThread object\n  OSThread* osthread = new OSThread(NULL, NULL);\n  if (osthread == NULL) {\n    return false;\n  }\n\n ...\n\n  // init thread attributes\n  pthread_attr_t attr;\n  pthread_attr_init(&attr);\n  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);\n\n  // Calculate stack size if it's not specified by caller.\n  size_t stack_size = os::Posix::get_initial_stack_size(thr_type, req_stack_size);\n  // In glibc versions prior to 2.7 the guard size mechanism\n  // is not implemented properly. The posix standard requires adding\n  // the size of the guard pages to the stack size, instead Linux\n  // takes the space out of 'stacksize'. Thus we adapt the requested\n  // stack_size by the size of the guard pages to mimick proper\n  // behaviour. However, be careful not to end up with a size\n  // of zero due to overflow. Don't add the guard page in that case.\n  size_t guard_size = os::Linux::default_guard_size(thr_type);\n  // Configure glibc guard page. Must happen before calling\n  // get_static_tls_area_size(), which uses the guard_size.\n  pthread_attr_setguardsize(&attr, guard_size);\n\n  size_t stack_adjust_size = 0;\n  if (AdjustStackSizeForTLS) {\n    // Adjust the stack_size for on-stack TLS - see get_static_tls_area_size().\n    stack_adjust_size += get_static_tls_area_size(&attr);\n  } else {\n    stack_adjust_size += guard_size;\n  }\n\n  stack_adjust_size = align_up(stack_adjust_size, os::vm_page_size());\n  if (stack_size <= SIZE_MAX - stack_adjust_size) {\n    stack_size += stack_adjust_size;\n  }\n  assert(is_aligned(stack_size, os::vm_page_size()), \"stack_size not aligned\");\n\n  int status = pthread_attr_setstacksize(&attr, stack_size);\n  assert_status(status == 0, status, \"pthread_attr_setstacksize\");\n\n  ThreadState state;\n\n  {\n    pthread_t tid;\n    int ret = pthread_create(&tid, &attr, (void* (*)(void*)) thread_native_entry, thread);\n\n    char buf[64];\n    if (ret == 0) {\n      log_info(os, thread)(\"Thread started (pthread id: \" UINTX_FORMAT \", attributes: %s). \",\n        (uintx) tid, os::Posix::describe_pthread_attr(buf, sizeof(buf), &attr));\n    } else {\n      log_warning(os, thread)(\"Failed to start thread - pthread_create failed (%s) for attributes: %s.\",\n        os::errno_name(ret), os::Posix::describe_pthread_attr(buf, sizeof(buf), &attr));\n      // Log some OS information which might explain why creating the thread failed.\n      log_info(os, thread)(\"Number of threads approx. running in the VM: %d\", Threads::number_of_threads());\n      LogStream st(Log(os, thread)::info());\n      os::Posix::print_rlimit_info(&st);\n      os::print_memory_info(&st);\n      os::Linux::print_proc_sys_info(&st);\n      os::Linux::print_container_info(&st);\n    }\n    ...\n    pthread_attr_destroy(&attr);\n    ...\n  return true;\n}\n
\n

threadnativeentry thread->call_run() 方法执行 java.lang.Thread#run()

\n
    \n
  1. java 调用 native 方法 start0()
    2. \n
  2. start0 映射到 jvm 中的 JVMStartThread(&threadentry, sz)
    3. \n
  3. JVM_StartThread 中 new JavaThread 对象，第一个构造参数映射 java 对象相关信息
    4. \n
  4. JavaThread 构造函数会调用 os 的 creat_thread 方法
    5. \n
  5. creatthread 调用 POSIX Thread `pthreadcreate`
    6. \n
  6. pthread_create 执行 run 回调函数
    7. \n
  7. java.lang.Thread#start() 方法调用完成,JVM 所创建的 JavaThread 对象就移除（delete this）
    8. \n
\n

当 java.lang.Thread#start() 方法调用完成， JVM 所创建的 JavaThread 对象就移除（delete this）。此时 java.lang.Thread 对象还没有回收。

\n

自旋锁(spinlocks)\nthread.cpp SpinAcquire\nCLH 队列

\n\n
join
\n

调用 Object 的 native 方法 wait:

\n
public class Object {\n    ...\n    public final native void wait(long timeout) throws InterruptedException;\n    ...\n}\n
\n

代码位置（jdk8）：\nObject.c (java.lang.Object 中的 native 方法都在这里做了映射) native 方法映射 wait - JVMMonitorWait\njvm.cpp JVMENTRY(void, JVM_MonitorWait)

\n
JVM_ENTRY(void, JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms))\n  JVMWrapper(\"JVM_MonitorWait\");\n  Handle obj(THREAD, JNIHandles::resolve_non_null(handle));\n  JavaThreadInObjectWaitState jtiows(thread, ms != 0);\n  if (JvmtiExport::should_post_monitor_wait()) {\n    JvmtiExport::post_monitor_wait((JavaThread *)THREAD, (oop)obj(), ms);\n\n    // The current thread already owns the monitor and it has not yet\n    // been added to the wait queue so the current thread cannot be\n    // made the successor. This means that the JVMTI_EVENT_MONITOR_WAIT\n    // event handler cannot accidentally consume an unpark() meant for\n    // the ParkEvent associated with this ObjectMonitor.\n  }\n  ObjectSynchronizer::wait(obj, ms, CHECK);\nJVM_END\n
\n

ObjectSynchronizer::wait(obj, ms, CHECK); 会创建膨胀锁

\n

CLH 自旋\nAQS.Node CLH 变体双向队列节点阻塞]

\n

JVM parkEvent->park 及 jdk LockSupport.park(this) 底层同为 pthread_cond_wait 函数

\n

volatile 原理

\n

volatile 是一个 c++ 语意。

\n

垃圾回收

\n

线程

\n

I/O

\n

jdk11

\n

quote

\n\n

TODO

\n

CLH\nUnsafe\nOS\nwait\npark\nyield\nnotify

\n","frontmatter":{"date":"May 31, 2020","title":"JVM","description":"JVM","tags":["JAVA","JVM","jconsole"]}}},"pageContext":{"id":"5e0a022a-c12b-5154-816a-77545536cc67"}}}