聊聊 Java 并发——基石篇（上）

CPU --> cache --> 存储

int a = value1;int b = value2;

/* Make sure registerNatives is the first thing <clinit> does. */private static native void registerNatives();static {    registerNatives();}

public static native Thread currentThread();        public static native void yield();    public static native void sleep(long millis) throws InterruptedException;    private native void start0();    private native boolean isInterrupted(boolean ClearInterrupted);    public final native boolean isAlive();    public native int countStackFrames();    public static native boolean holdsLock(Object obj);    private static native StackTraceElement[][] dumpThreads(Thread[] threads);    private static native Thread[] getThreads();    private native void setPriority0(int newPriority);    private native void stop0(Object o);    private native void suspend0();    private native void resume0();    private native void interrupt0();    private native void setNativeName(String name);

java_lang_Thread_registerNatives

static JNINativeMethod methods[] = {    {"start0",           "()V",        (void *)&JVM_StartThread},    {"stop0",            "(" OBJ ")V", (void *)&JVM_StopThread},    {"isAlive",          "()Z",        (void *)&JVM_IsThreadAlive},    {"suspend0",         "()V",        (void *)&JVM_SuspendThread},    {"resume0",          "()V",        (void *)&JVM_ResumeThread},    {"setPriority0",     "(I)V",       (void *)&JVM_SetThreadPriority},    {"yield",            "()V",        (void *)&JVM_Yield},    {"sleep",            "(J)V",       (void *)&JVM_Sleep},    {"currentThread",    "()" THD,     (void *)&JVM_CurrentThread},    {"countStackFrames", "()I",        (void *)&JVM_CountStackFrames},    {"interrupt0",       "()V",        (void *)&JVM_Interrupt},    {"isInterrupted",    "(Z)Z",       (void *)&JVM_IsInterrupted},    {"holdsLock",        "(" OBJ ")Z", (void *)&JVM_HoldsLock},    {"getThreads",        "()[" THD,   (void *)&JVM_GetAllThreads},    {"dumpThreads",      "([" THD ")[[" STE, (void *)&JVM_DumpThreads},    {"setNativeName",    "(" STR ")V", (void *)&JVM_SetNativeThreadName},};JNIEXPORT void JNICALLJava_java_lang_Thread_registerNatives(JNIEnv *env, jclass cls){    (*env)->RegisterNatives(env, cls, methods, ARRAY_LENGTH(methods));}

/* * used in RegisterNatives to describe native method name, signature, * and function pointer. */typedef struct {    char *name;    char *signature;    void *fnPtr;} JNINativeMethod;

JVM_ENTRY(void, JVM_StartThread(JNIEnv* env, jobject jthread))  JVMWrapper("JVM_StartThread");  JavaThread *native_thread = NULL;
  // We cannot hold the Threads_lock when we throw an exception,  // due to rank ordering issues. Example:  we might need to grab the  // Heap_lock while we construct the exception.  bool throw_illegal_thread_state = false;
  // We must release the Threads_lock before we can post a jvmti event  // in Thread::start.  {    // Ensure that the C++ Thread and OSThread structures aren't freed before    // we operate.    MutexLocker mu(Threads_lock);
    // Since JDK 5 the java.lang.Thread threadStatus is used to prevent    // re-starting an already started thread, so we should usually find    // that the JavaThread is null. However for a JNI attached thread    // there is a small window between the Thread object being created    // (with its JavaThread set) and the update to its threadStatus, so we    // have to check for this    if (java_lang_Thread::thread(JNIHandles::resolve_non_null(jthread)) != NULL) {      throw_illegal_thread_state = true;    } else {      // We could also check the stillborn flag to see if this thread was already stopped, but      // for historical reasons we let the thread detect that itself when it starts running
      jlong size =             java_lang_Thread::stackSize(JNIHandles::resolve_non_null(jthread));      // Allocate the C++ Thread structure and create the native thread.  The      // stack size retrieved from java is 64-bit signed, but the constructor takes      // size_t (an unsigned type), which may be 32 or 64-bit depending on the platform.      //  - Avoid truncating on 32-bit platforms if size is greater than UINT_MAX.      //  - Avoid passing negative values which would result in really large stacks.      NOT_LP64(if (size > SIZE_MAX) size = SIZE_MAX;)      size_t sz = size > 0 ? (size_t) size : 0;      // 重点看这里！！！      native_thread = new JavaThread(&thread_entry, sz);
      // At this point it may be possible that no osthread was created for the      // JavaThread due to lack of memory. Check for this situation and throw      // an exception if necessary. Eventually we may want to change this so      // that we only grab the lock if the thread was created successfully -      // then we can also do this check and throw the exception in the      // JavaThread constructor.      if (native_thread->osthread() != NULL) {        // Note: the current thread is not being used within "prepare".        native_thread->prepare(jthread);      }    }  }
  if (throw_illegal_thread_state) {    THROW(vmSymbols::java_lang_IllegalThreadStateException());  }
  assert(native_thread != NULL, "Starting null thread?");
  if (native_thread->osthread() == NULL) {    // No one should hold a reference to the 'native_thread'.    native_thread->smr_delete();    if (JvmtiExport::should_post_resource_exhausted()) {      JvmtiExport::post_resource_exhausted(        JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR | JVMTI_RESOURCE_EXHAUSTED_THREADS,        os::native_thread_creation_failed_msg());    }    THROW_MSG(vmSymbols::java_lang_OutOfMemoryError(),              os::native_thread_creation_failed_msg());  }
  Thread::start(native_thread);
JVM_END

native_thread = new JavaThread(&thread_entry, sz);

JavaThread::JavaThread(ThreadFunction entry_point, size_t stack_sz) :                       Thread() {  initialize();  _jni_attach_state = _not_attaching_via_jni;  set_entry_point(entry_point);  // Create the native thread itself.  // %note runtime_23  os::ThreadType thr_type = os::java_thread;  thr_type = entry_point == &compiler_thread_entry ? os::compiler_thread :                                                     os::java_thread;  // 通过 os 类的 create_thread 函数来创建一个线程  os::create_thread(this, thr_type, stack_sz);  // The _osthread may be NULL here because we ran out of memory (too many threads active).  // We need to throw and OutOfMemoryError - however we cannot do this here because the caller  // may hold a lock and all locks must be unlocked before throwing the exception (throwing  // the exception consists of creating the exception object & initializing it, initialization  // will leave the VM via a JavaCall and then all locks must be unlocked).  //  // The thread is still suspended when we reach here. Thread must be explicit started  // by creator! Furthermore, the thread must also explicitly be added to the Threads list  // by calling Threads:add. The reason why this is not done here, is because the thread  // object must be fully initialized (take a look at JVM_Start)}

bool os::create_thread(Thread* thread, ThreadType thr_type,                       size_t req_stack_size) {  ...  // init thread attributes  pthread_attr_t attr;  pthread_attr_init(&attr);  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);  // Calculate stack size if it's not specified by caller.  size_t stack_size = os::Posix::get_initial_stack_size(thr_type, req_stack_size);  // In the Linux NPTL pthread implementation the guard size mechanism  // is not implemented properly. The posix standard requires adding  // the size of the guard pages to the stack size, instead Linux  // takes the space out of 'stacksize'. Thus we adapt the requested  // stack_size by the size of the guard pages to mimick proper  // behaviour. However, be careful not to end up with a size  // of zero due to overflow. Don't add the guard page in that case.  size_t guard_size = os::Linux::default_guard_size(thr_type);  if (stack_size <= SIZE_MAX - guard_size) {    stack_size += guard_size;  }  assert(is_aligned(stack_size, os::vm_page_size()), "stack_size not aligned");
  int status = pthread_attr_setstacksize(&attr, stack_size);  assert_status(status == 0, status, "pthread_attr_setstacksize");
  // Configure glibc guard page.  pthread_attr_setguardsize(&attr, os::Linux::default_guard_size(thr_type));  ...  pthread_t tid;  // 创建并启动线程  int ret = pthread_create(&tid, &attr, (void* (*)(void*)) thread_native_entry, thread);  ...}

pthread_t tid;// 创建并启动线程int ret = pthread_create(&tid, &attr, (void* (*)(void*)) thread_native_entry, thread);

intpthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg);

// Thread start routine for all newly created threadsstatic void *thread_native_entry(Thread *thread) {  ...  // call one more level start routine  thread->run();  ...}

os::create_thread(this, thr_type, stack_sz);

// The first routine called by a new Java threadvoid JavaThread::run() {  ...  // We call another function to do the rest so we are sure that the stack addresses used  // from there will be lower than the stack base just computed  thread_main_inner();}

void JavaThread::thread_main_inner() {  assert(JavaThread::current() == this, "sanity check");  assert(this->threadObj() != NULL, "just checking");
  // Execute thread entry point unless this thread has a pending exception  // or has been stopped before starting.  // Note: Due to JVM_StopThread we can have pending exceptions already!  if (!this->has_pending_exception() &&      !java_lang_Thread::is_stillborn(this->threadObj())) {    {      ResourceMark rm(this);      this->set_native_thread_name(this->get_thread_name());    }    HandleMark hm(this);    // 这里开始调用 java thread 的 run 方法啦～～～    this->entry_point()(this, this);  }
  DTRACE_THREAD_PROBE(stop, this);
  // java 中的 run 方法执行完毕了，这里需要退出线程并清理资源  this->exit(false);  // delete cpp 的对象  this->smr_delete();}

ThreadFunction entry_point() const             { return _entry_point; }

typedef void (*ThreadFunction)(JavaThread*, TRAPS);

native_thread = new JavaThread(&thread_entry, sz);

JavaThread::JavaThread(ThreadFunction entry_point, size_t stack_sz) :                       Thread() {   ...   set_entry_point(entry_point);   ...}

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

#define VM_SYMBOL_DECLARE(name, ignore)                 \    static Symbol* name() {                               \      return _symbols[VM_SYMBOL_ENUM_NAME(name)];         \    }  VM_SYMBOLS_DO(VM_SYMBOL_DECLARE, VM_SYMBOL_DECLARE)  #undef VM_SYMBOL_DECLARE

template(run_method_name,                           "run")  \

template(void_method_signature,                     "()V")  \