并发编程之多线程概念

进程和线程

　　说到多线程，必然绕不开进程与线程的概念及区别。

　　对于计算机而言，当前的操做系统能够同时运行多个应用程序，而每个应用程序就是一个进程（Process），它拥有本身独立的内存空间。线程是进程中的一个执行流程，是执行任务的最小单位。一个进程内部容许同时启动多个线程（Thread），同时执行多个任务。线程是轻量级的进程，它负责在单个程序里执行多任务，一般由操做系统负责多个线程的调度和执行。 

　　进程与线程的主要区别在于：每一个进程都须要操做系统为其分配独立的内存空间，而同一个进程中的全部线程在同一块地址空间中，这些线程能够共享数据。【每一个进程都拥有本身的一套变量，而线程能够共享数据】 

 

多线程

 

　　多线程是并发编程的基础。

 

　　多线程的好处在于能够同时并发执行多个任务。当程序的某个功能部分正在等待资源而又不肯意由于等待而形成程序暂停，就能够建立另外的线程进行它的工做。

 

　　多线程能够最大限度地下降CPU的闲置时间，从而提升CPU的利用率。

 

主存与工做内存

 

　　多线程将内存抽象为两类：主内存和工做内存。主内存，简称主存，是全部线程共享的内存，主要存放共享的变量（即：类变量）。工做内存是Java线程的本地内存，是单独给每个线程分配的特有的工做内存，用来存放局部变量和共享变量的副本。

 

　　既然主内存已经存有共享变量，为什么还有在工做内存中存放共享变量的副本呢？缘由在于线程与主存之间的通讯效率比较低，频繁的通讯会下降系统性能。当线程进行读写操做时，只须要对工做内存中的变量进行操做。【关于主存和工做内存请查看 并发编程之Java内存模型 】

 

 线程的生命周期

 

　　从JDK的源码（sun.misc.VM#toThreadState）中，咱们能够看出，线程的生命周期分为６个状态：NEW（新建立）、RUNNANLE（可运行）、BLOCKED（被阻塞）、WAITING（等待）、TIMED_WAITING（计时等待）、TERMINATED（中终止）．

/**
* A thread state.  A thread can be in one of the following states:
* <ul>
* <li>{@link #NEW}
*     A thread that has not yet started is in this state.
* </li>
* <li>{@link #RUNNABLE}
*     A thread executing in the Java virtual machine is in this state.
*</li>
* <li>{@link #BLOCKED}
*     A thread that is blocked waiting for a monitor lock
*     is in this state.
* </li>
* <li>{@link #WAITING}
*     A thread that is waiting indefinitely for another thread to
*     perform a particular action is in this state.
* </li>
* <li>{@link #TIMED_WAITING}
*     A thread that is waiting for another thread to perform an action
*     for up to a specified waiting time is in this state.
* </li>
* <li>{@link #TERMINATED}
*     A thread that has exited is in this state.
* </li>
* </ul>
*
* <p>
* A thread can be in only one state at a given point in time.
* These states are virtual machine states which do not reflect
* any operating system thread states.
*
* @since   1.5
* @see #getState
*/

public static State toThreadState(int var0) {
    if ((var0 & 4) != 0) {
        return State.RUNNABLE;
    } else if ((var0 & 1024) != 0) {
        return State.BLOCKED;
    } else if ((var0 & 16) != 0) {
        return State.WAITING;
    } else if ((var0 & 32) != 0) {
        return State.TIMED_WAITING;
    } else if ((var0 & 2) != 0) {
        return State.TERMINATED;
    } else {
        return (var0 & 1) == 0 ? State.NEW : State.RUNNABLE;
    }
}

 

　　线程状态之间的转换关系以下图：

                

 

• 刚建立的线程处于NEW状态
• 调用start（）后，线程处于RUNNANLE状态【线程什么时候开始执行任务，受CPU的控制。当CPU有空闲资源时，才会运行线程】
• 在等待获取锁资源的时候，线程会处于BLOCKED状态
• 线程在等待另外一个线程的通知时，会处于WAITING状态
• 线程在指定时间内等待另外一个线程通知，会处于TIMED_WAITING状态
• 线程运行结束或出现异常，就会变为TERMINATED状态
• 获取线程的当前状态：getState()

public Thread.State getState() {
    return VM.toThreadState(this.threadStatus);
}

 

　　从源码中能够看出，线程的状态与VM有很大的关系。在JVM中，与线程建立、运行、销毁等关系比较大的是Java虚拟机栈内存。【JVM的基本机构可查看JVM之基本结构 】