「阿里面试系列」面试加分项，从JVM层面了解线程的启动和停止

文章简介

这一篇主要围绕线程状态控制相关的操作分析线程的原理，比如线程的中断，线程的通信等，内容比较多，可能会分两篇文章

阿里面试系列导读：关注我的技术公众号【架构师修炼宝典】一周出产1-2篇技术文章。

【阿里面试系列】搞懂并发编程，轻松应对80%的面试场景

【阿里面试系列】Java线程的应用及挑战

内容导航

  1. 线程的启动的实现原理
  2. 线程停止的实现原理分析
  3. 为什么中断线程会抛出InterruptedException的

线程的启动原理

前面我们简单分析过了线程的使用，通过调用线程的启动方法来启动线程，线程启动后会调用运行方法执行业务逻辑，运行方法执行完毕后，线程的生命周期也就终止了。
很多同学最早学习线程的时候会比较疑惑，启动一个线程为什么是调用启动方法，而不是运行方法，这做一个简单的分析，先简单看一下启动方法的定义

public class Thread implements Runnable {
...
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 */
            }
        }
    }
    private native void start0();//注意这里
...

我们看到调用启动方法实际上是调用一个本地方法START0（）来启动一个线程，首先START0（）这个方法是在线程的静态块中来注册的，代码如下

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

这个registerNatives的作用是注册一些本地方法提供给Thread类来使用，比如start0（），isAlive（），currentThread（），sleep（）;这些都是大家很熟悉的方法.registerNatives
的本地方法的定义在文件Thread.c，
Thread.c定义了各个操作系统平台要用的关于线程的公共数据和操作，以下是Thread.c的全部内容

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},
};
#undef THD
#undef OBJ
#undef STE
#undef STR
JNIEXPORT void JNICALL
Java_java_lang_Thread_registerNatives(JNIEnv *env, jclass cls)
{
    (*env)->RegisterNatives(env, cls, methods, ARRAY_LENGTH(methods));
}

从这段代码可以看出，start0（），实际会执行JVM_StartThread方法，这个方法是干嘛的呢？从名字上来看，似乎是在JVM层面去启动一个线程，如果真的是这样，那么在JVM层面，一定会调用Java中定义的运行方法。那接下来继续去找找答案。我们找到jvm.cpp这个文件;这个文件需要下载hotspot的源码才能找到。

JVM_ENTRY(void, JVM_StartThread(JNIEnv* env, jobject jthread))
  JVMWrapper("JVM_StartThread");
...
native_thread = new JavaThread(&thread_entry, sz);
...

JVM_ENTRY是用来定义JVM_StartThread函数的，在这个函数里面创建了一个真正和平台有关的本地线程。本着打破砂锅查到底的原则，继续看看newJavaThread做了什么事情，继续寻找JavaThread的定义
在hotspot的源码中thread.cpp文件中1558行的位置可以找到如下代码

JavaThread::JavaThread(ThreadFunction entry_point, size_t stack_sz) :
  Thread()
#if INCLUDE_ALL_GCS
  , _satb_mark_queue(&_satb_mark_queue_set),
  _dirty_card_queue(&_dirty_card_queue_set)
#endif // INCLUDE_ALL_GCS
{
  if (TraceThreadEvents) {
    tty->print_cr("creating thread %p", this);
  }
  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(this, thr_type, stack_sz);
  _safepoint_visible = false;
  // 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)
}

这个方法有两个参数，第一个是函数名称，线程创建成功之后会根据这个函数名称调用对应的函数;第二个是当前进程内已经有的线程数量。最后我们重点关注与一下os :: create_thread，实际就是调用平台创建线程的方法来创建线程。
接下来就是线程的启动，会调用Thread.cpp文件中的Thread :: start（Thread * thread）方法，代码如下

void Thread::start(Thread* thread) {
  trace("start", thread);
  // Start is different from resume in that its safety is guaranteed by context or
  // being called from a Java method synchronized on the Thread object.
  if (!DisableStartThread) {
    if (thread->is_Java_thread()) {
      // Initialize the thread state to RUNNABLE before starting this thread.
      // Can not set it after the thread started because we do not know the
      // exact thread state at that time. It could be in MONITOR_WAIT or
      // in SLEEPING or some other state.
      java_lang_Thread::set_thread_status(((JavaThread*)thread)->threadObj(),
                                          java_lang_Thread::RUNNABLE);
    }
    os::start_thread(thread);
  }
}

启动方法中有一个函数调用：os :: start_thread（thread）;,调用平台启动线程的方法，最终会调用Thread.cpp文件中的JavaThread :: run（）方法

// The first routine called by a new Java thread
void JavaThread::run() {
  // initialize thread-local alloc buffer related fields
  this->initialize_tlab();
  // used to test validitity of stack trace backs
  this->record_base_of_stack_pointer();
  // Record real stack base and size.
  this->record_stack_base_and_size();
  // Initialize thread local storage; set before calling MutexLocker
  this->initialize_thread_local_storage();
  this->create_stack_guard_pages();
  this->cache_global_variables();
  // Thread is now sufficient initialized to be handled by the safepoint code as being
  // in the VM. Change thread state from _thread_new to _thread_in_vm
  ThreadStateTransition::transition_and_fence(this, _thread_new, _thread_in_vm);
  assert(JavaThread::current() == this, "sanity check");
  assert(!Thread::current()->owns_locks(), "sanity check");
  DTRACE_THREAD_PROBE(start, this);
  // This operation might block. We call that after all safepoint checks for a new thread has
  // been completed.
  this->set_active_handles(JNIHandleBlock::allocate_block());
  if (JvmtiExport::should_post_thread_life()) {
    JvmtiExport::post_thread_start(this);
  }
  EventThreadStart event;
  if (event.should_commit()) {
     event.set_javalangthread(java_lang_Thread::thread_id(this->threadObj()));
     event.commit();
  }
  // 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();
  // Note, thread is no longer valid at this point!
}

这个方法中主要是做一系列的初始化操作，最后有一个方法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);
    this->entry_point()(this, this);
  }
  DTRACE_THREAD_PROBE(stop, this);
  this->exit(false);
  delete this;
}

和主流程无关的代码咱们先不去看，直接找到最核心的代码块this-> entry_point（）（this，this）;,这个entrypoint应该比较熟悉了，因为我们在前面提到了，在:: JavaThread这个方法中传递的第一个参数，代表函数名称，线程启动的时候会调用这个函数。
如果大家还没有晕车的话，应该记得我们在jvm.cpp文件中看到的代码，在创建native_thread = newJavaThread（ ＆thread_entry，SZ）; 的时候传递了一个threadentry函数，所以我们在jvm.cpp中找到这个函数的定义如下

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);
}

可以看到vmSymbols :: run_method_name（）这个调用，其实就是通过回调方法调用Java线程中定义的运行方法，run_method_name是一个宏定义，在vmSymbols.hpp文件中可以找到如下代码

#define VM_SYMBOLS_DO(template, do_alias)    
...
template(run_method_name, "run")  
...

所以结论就是，Java的里面创建线程之后必须要调用启动方法才能真正的创建一个线程，该方法会调用虚拟机启动一个本地线程，本地线程的创建会调用当前系统创建线程的方法进行创建，并且线程被执行的时候会回调跑方法进行业务逻辑的处理

线程的终止方法及原理

线程的终止有主动和被动之分，被动表示线程出现异常退出或者运行方法执行完毕，线程会自动终止。主动的方式是Thread.stop（）来实现线程的终止，但是停止（）方法是一个过期的方法，官方是不建议使用，理由很简单，停止（）方法在中介一个线程时不会保证线程的资源正常释放，也就是不会给线程完成资源释放工作的机会，相当于我们在Linux的上通过kill -9强制结束一个进程。

那么如何安全的终止一个线程呢？
我们先看一下下面的代码，代码演示了一个正确终止线程的方法，至于它的实现原理，稍后我们再分析

public class InterruptedDemo implements Runnable{
    @Override
    public void run() {
        long i=0l;
        while(!Thread.currentThread().isInterrupted()){//notice here
            i++;
        }
        System.out.println("result:"+i);
    }
    public static void main(String[] args) throws InterruptedException {
        InterruptedDemo interruptedDemo=new InterruptedDemo();
        Thread thread=new Thread(interruptedDemo);
        thread.start();
        Thread.sleep(1000);//睡眠一秒
        thread.interrupt();//notice here
    }
}

代码中有两处需要注意，在主线程中，调用了线程的interrupt（）方法，在运行方法中，而循环中通过Thread.currentThread（）。isInterrupted（）来判断线程中断的标识。所以我们在这里猜想一下，应该是在线程中维护了一个中断标识，通过thread.interrupt（）方法去改变了中断标识的值使得运行方法中而循环的判断不成立而跳出循环，因此运行方法执行完毕以后线程就终止了。

线程中断的原理分析

我们来看一下thread.interrupt（）方法做了什么事情

public class Thread implements Runnable {
...
    public void interrupt() {
        if (this != Thread.currentThread())
            checkAccess();
        synchronized (blockerLock) {
            Interruptible b = blocker;
            if (b != null) {
                interrupt0();           // Just to set the interrupt flag
                b.interrupt(this);
                return;
            }
        }
        interrupt0();
    }
...

这个方法里面，调用了中断0（），这个方法在前面分析启动方法的时候见过，是一个本机方法，这里就不再重复贴代码了，同样，我们找到jvm.cpp文件，找到JVM_Interrupt的定义

JVM_ENTRY(void, JVM_Interrupt(JNIEnv* env, jobject jthread))
  JVMWrapper("JVM_Interrupt");
  // Ensure that the C++ Thread and OSThread structures aren't freed before we operate
  oop java_thread = JNIHandles::resolve_non_null(jthread);
  MutexLockerEx ml(thread->threadObj() == java_thread ? NULL : Threads_lock);
  // We need to re-resolve the java_thread, since a GC might have happened during the
  // acquire of the lock
  JavaThread* thr = java_lang_Thread::thread(JNIHandles::resolve_non_null(jthread));
  if (thr != NULL) {
    Thread::interrupt(thr);
  }
JVM_END

这个方法比较简单，直接调用了Thread :: interrupt（thr）这个方法，这个方法的定义在Thread.cpp文件中，代码如下

void Thread::interrupt(Thread* thread) {
  trace("interrupt", thread);
  debug_only(check_for_dangling_thread_pointer(thread);)
  os::interrupt(thread);
}

Thread :: interrupt方法调用了os :: interrupt方法，这个是调用平台的中断方法，这个方法的实现是在os _ * .cpp文件中，其中星号代表的是不同平台，因为jvm是跨平台的，所以对于不同的操作平台，线程的调度方式都是不一样的。我们以os_linux.cpp文件为例

void os::interrupt(Thread* thread) {
  assert(Thread::current() == thread || Threads_lock->owned_by_self(),
    "possibility of dangling Thread pointer");
  //获取本地线程对象
  OSThread* osthread = thread->osthread();
  if (!osthread->interrupted()) {//判断本地线程对象是否为中断
    osthread->set_interrupted(true);//设置中断状态为true
    // More than one thread can get here with the same value of osthread,
    // resulting in multiple notifications.  We do, however, want the store
    // to interrupted() to be visible to other threads before we execute unpark().
    //这里是内存屏障，这块在后续的文章中会剖析；内存屏障的目的是使得interrupted状态对其他线程立即可见
    OrderAccess::fence();
    //_SleepEvent相当于Thread.sleep，表示如果线程调用了sleep方法，则通过unpark唤醒
    ParkEvent * const slp = thread->_SleepEvent ;
    if (slp != NULL) slp->unpark() ;
  }
  // For JSR166\. Unpark even if interrupt status already was set
  if (thread->is_Java_thread())
    ((JavaThread*)thread)->parker()->unpark();
  //_ParkEvent用于synchronized同步块和Object.wait()，这里相当于也是通过unpark进行唤醒
  ParkEvent * ev = thread->_ParkEvent ;
  if (ev != NULL) ev->unpark() ;
}

通过上面的代码分析可以知道，了Thread.interrupt（）方法实际就是设置一个中断状态标识为真，并且通过ParkEvent的取消驻留方法来唤醒线程。

  1. 对于同步阻塞的线程，被唤醒以后会继续尝试获取锁，如果失败仍然可能被公园
  2. 在调用ParkEvent的公园方法之前，会先判断线程的中断状态，如果为真，会清除当前线程的中断标识
  3. 的Object.wait，了Thread.sleep，的Thread.join会抛出InterruptedException的

这里给大家普及一个知识点，为什么的Object.wait，的Thread.sleep和的Thread.join都会抛出InterruptedException的？首先，这个异常的意思是表示一个阻塞被其他线程中断了。然后，由于线程调用了中断（）中断方法，那么的Object.wait，的Thread.sleep等被阻塞的线程被唤醒以后会通过is_interrupted方法判断中断标识的状态变化，如果发现中断标识为真，则先清除中断标识，然后抛出InterruptedException的

需要注意的是，InterruptedException的异常的抛出并不意味着线程必须终止，而是提醒当前线程有中断的操作发生，至于接下来怎么处理取决于线程本身，比如

  1. 直接捕获异常不做任何处理
  2. 将异常往外抛出
  3. 停止当前线程，并打印异常信息
  4. 关注我的技术公众号【Java架构师学习】一周出产1-2篇技术文章。
  5. Q裙725219329我在分享并发编程，分布式，微服务架构，性能优化，源码，设计模式，高并发，高可用，春，Netty中，Tomcat时，JVM等技术视频。

为了让大家能够更好的理解上面这段话，我们以了Thread.sleep为例直接从JDK的源码中找到中断标识的清除以及异常抛出的方法代码

找到is_interrupted（）方法，linux平台中的实现在os_linux.cpp文件中，代码如下

bool os::is_interrupted(Thread* thread, bool clear_interrupted) {
  assert(Thread::current() == thread || Threads_lock->owned_by_self(),
    "possibility of dangling Thread pointer");
  OSThread* osthread = thread->osthread();
  bool interrupted = osthread->interrupted(); //获取线程的中断标识
  if (interrupted && clear_interrupted) {//如果中断标识为true
    osthread->set_interrupted(false);//设置中断标识为false
    // consider thread->_SleepEvent->reset() ... optional optimization
  }
  return interrupted;
}

找到了Thread.sleep这个操作在JDK中的源码体现，怎么找？相信如果前面大家有认真看的话，应该能很快找到，代码在jvm.cpp文件中

JVM_ENTRY(void, JVM_Sleep(JNIEnv* env, jclass threadClass, jlong millis))
  JVMWrapper("JVM_Sleep");
  if (millis < 0) {
    THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "timeout value is negative");
  }
  //判断并清除线程中断状态，如果中断状态为true,抛出中断异常
  if (Thread::is_interrupted (THREAD, true) && !HAS_PENDING_EXCEPTION) {
    THROW_MSG(vmSymbols::java_lang_InterruptedException(), "sleep interrupted");
  }
  // Save current thread state and restore it at the end of this block.
  // And set new thread state to SLEEPING.
  JavaThreadSleepState jtss(thread);
...

注意上面加了中文注释的地方的代码，先判断is_interrupted的状态，然后抛出一个InterruptedException的异常。到此为止，我们就已经分析清楚了中断的整个流程。

Java的线程的中断标识判断

了解了线程。中断方法的作用以后，再回过头来看Java中Thread.currentThread（）。isInterrupted（）这段代码，就很好理解了。由于前者先设置了一个中断标识为真，所以isInterrupted（ ）这个方法的返回值为真，故而不满足而循环的判断条件导致退出循环。
这里有必要再提一句，就是这个线程中断标识有两种方式复位，第一种是前面提到过的InterruptedException的;另一种是通过Thread.interrupted（）对当前线程的中断标识进行复位。

©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 198,082评论 5赞 464
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 83,231评论 2赞 375
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 145,047评论 0赞 327
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 52,977评论 1赞 268
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 61,893评论 5赞 359
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 47,014评论 1赞 275
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 36,976评论 3赞 388
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 35,605评论 0赞 254
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 39,888评论 1赞 293
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 34,906评论 2赞 314
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 36,732评论 1赞 328
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 32,513评论 3赞 316
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 37,980评论 3赞 301
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,132评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 30,447评论 1赞 255
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 42,027评论 2赞 343
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 41,232评论 2赞 339

推荐阅读更多精彩内容

  • (三)从jvm层面了解线程的启动和停止
    文章简介 这一篇主要围绕线程状态控制相关的操作分析线程的原理，比如线程的中断、线程的通信等，内容比较多，可能会分两...
    跟着Mic学架构阅读 580评论 0赞 1
  • JAVA多线程
    进程和线程 进程 所有运行中的任务通常对应一个进程,当一个程序进入内存运行时,即变成一个进程.进程是处于运行过程中...
    胜浩_ae28阅读 5,082评论 0赞 23
  • Java多线程学习之并发基础
    单任务 单任务的特点是排队执行，也就是同步，就像再cmd输入一条命令后，必须等待这条命令执行完才可以执行下一条命令...
    Steven1997阅读 1,159评论 0赞 6
  • java并发的多线程
    本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。在这之前...
    4ea0af17fd67阅读 586评论 2赞 17
  • 驳《你坚持日更的样子真失败》
    今天偶然在简书上看到谦行公子的一篇文章：《你坚持日更的样子真失败》。文中的第一句话便是：“看了标题后，相信有很多读...
    小诺z阅读 357评论 7赞 9