jvm(12)-java内存模型与线程

时间  2019-12-10
标签 jvm java 内存 模型 线程 栏目 Java 繁體版
原文   原文链接
【0】README
0.1）本文部分文字描述转自“深刻理解jvm”，旨在学习 “java内存模型与线程” 的基础知识；
 
【1】概述
1）并发处理的普遍应用是使得 Amdahl 定律代替摩尔定律称为计算机性能发展源动力的根本缘由；
2）Amdahl 定律：该定律经过系统中并行化与串行化的比重来描述多处理器系统能得到的运算加速能力；
3）摩尔定律：该定律用于描述处理器晶体管数量与运行效率间的发展关系；
Conclusion）这两个定律的更替表明了近年来硬件发展从追求处理器频率到追求多核心并行处理的发展过程；
 
【2】硬件的效率与一致性
1）高速缓存（干货——引入高速缓存）
  • 1.1）problem：因为计算机的存储设备与处理器的运算速率有几个数量级的差距；
  • 1.2）solution：引入一层读写速度尽量接近处理器速度的高速缓存（cache） 来做为内存与处理器间的缓冲： 将运算须要使用到的数据复制到缓存中，让运算能快速进行，当运算结束后再从缓冲同步回内存中，这样处理器就无须等待缓慢的内存读写了；
2）缓存的引入产生了一个新问题——缓存一致性： 在多处理器系统中，每一个处理器都有本身的高速缓存，而它们又共享同一主内存，以下图所示：
  • 2.1）问题描述（problem）： 当多个处理器的运算任务都涉及到同一块内存区域时，将可能致使各自的缓存数据不一致，那同步到内存时以谁的数据为准呢？
  • 2.2）solution： 须要各个处理器遵循一些协议，在读写时要根据协议来进行操做，这类协议有 MSI， MESI，等。
  • 2.3）内存模型： 能够理解为 在特定的操做协议下，对特定的内存或高速缓存进行读写访问的过程抽象；（干货——java内存模型定义）
3）乱序执行： 为了使得处理器内部的运算单元可以被尽可能使用，处理器可能对输入代码进行乱序执行优化，处理器会在计算以后将乱序执行的结果重组，保证该结果与顺序执行的结果是一致的；
 
【3】java内存模型
0）intro to java内存模型：java虚拟机规范试图定义一种java内存模型（java memory model）来屏蔽掉各类硬件和操做系统的内存访问差别，以实现让java程序在各类平台下都能达到一致的内存访问效果；
【3.1】主内存与工做内存
1）java内存模型的主要目标：定义程序中各个变量的访问规则，即在虚拟机中将变量存储到内存和从内存中读取变量这样的底层细节；
2）java内存模型规定了：全部的变量都存储在主内存中。
  • 2.1）每条线程还有本身的工做内存： 线程的工做内存中保存了被该线程使用到的变量的主内存副本拷贝，线程对变量的全部操做（读取，赋值）都必须在工做内存中进行，而不能直接读写内存中的变量。不一样的线程之间也没法直接访问对方工做内存中的变量;（干货——每条线程还有本身的工做内存，工做内存定义）
  • 2.2）线程间变量值的传递均须要经过主内存来完成：线程、内存、工做内存三者关系以下所示：
3）这里所讲的主内存，工做内存与前面讲的 java内存区域中的java堆，栈，方法区等并非同一个层次的内存划分，这二者基本没有关系；
  • 3.1）若是硬要扯上关系，则：主内存主要对应于java堆中的对象实例数据部分，而工做内存则对应于虚拟机栈中的部分区域；
  • 3.2）更低层次上说：主内存就直接对应于物理硬件的内存，而为了得到更好的运行速度，虚拟机可能会让工做内存优先存储于寄存器和高速缓存中，由于程序运行时主要访问读写的是工做内存；
【3.2】内存间交互操做
1）关于主内存与工做内存间的交互协议，即一个变量如何从主内存拷贝到工做内存，如何从工做内存同步回主内存；java内存模型中定义了如下8种操做（operations）：（干货——java内存模型中定义了如下8种操做）
  • o1）lock（锁定）：做用于主内存的变量，它把一个变量标识为一条线程独占的状态；
  • o2）unlock（解锁）：做用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才能够被其余线程锁定；
  • o3）read（读取）：做用于主内存的变量，它把一个变量的值从主内存传输到线程的工做内存中，以便随后的load 动做使用；
  • o4）load（载入）：做用于工做内存的变量， 它把 read 操做从主内存中获得的变量放入工做内存的变量副本中；
  • o5）use（使用）：做用于工做内存的变量，它把工做内存中一个变量的值传递给执行引擎，每当虚拟机遇到一个须要使用到变量的值的字节码指令时将会执行这个操做；
  • o6）assign（赋值）：做用于工做内存的变量，它把一个从执行引擎接收到的值赋给工做内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操做；
  • o7）store（存储）：做用于工做内存的变量， 它把工做内存中一个变量的值传送到主内存中，以便随后的write操做使用；
  • o8）write（写入）：做用于主内存的变量， 它把store操做从工做内存中获得的变量的值放入主内存的变量中；
2）相关操做：
  • 2.1）把变量从主内存复制到工做内存：顺序执行read和load操做（目的地是工做内存）；
  • 2.2）把变量从工做内存同步回主内存：顺序执行store和write操做（目的地是主内存）；
  • Attention）java内存模型只要求上述两个操做必须按顺序执行，没有保证是连续执行；即read和 load 之间，store和 write之间能够插入其余指令；（干货——java内存模型只要求上述两个操做必须按顺序执行，没有保证是连续执行，它们之间还能够插入其余指令）
3）java内存模型还规定了在执行上述8种基本操做时必须知足以下规则（rules）：
  • r1）不容许read和 load，store 和 write操做之一单独出现，即不容许一个变量从主内存读取了但工做内存不接受，或者从工做内存发起回写了但主内存不接受的状况出现；
  • r2）不容许一个线程丢弃它的最近的assign操做，即变量在工做内存中改变了以后必须把该变化同步回主内存；
  • r3）不容许一个线程无缘由地（没有发生过任何 assign操做）把数据从线程的工做内存同步回主内存中；
  • r4）一个新变量只能在主内存中诞生，不容许在工做内存中直接使用一个未被初始化的变量，换句话说，对一个变量实施 use，store操做前，必须先执行过 assign 和 load 操做；
  • r5）一个变量在同一个时刻只容许一个线程对其进行lock 操做，但lock操做能够被同一条线程重复执行屡次，屡次执行 lock后，只有执行相同次数的unlock 操做，变量才会被解锁；
  • r6）若是对一个变量执行lock 操做，那将会清空工做内存中此变量的值，在执行引擎使用这个变量前，须要从新执行 load 或 assign 操做初始化变量的值；
  • r7）若是一个变量事先没有被lock操做锁定，那就不容许对它执行unlock操做，也不容许去 unlock 一个被其余线程锁定住的变量；
  • r8）对一个变量执行unlock 变量前，必须先把此变量同步回主内存中（执行store， write操做）；
  • Conclusion） 这8种内存访问操做以及上述规则限定，再加上稍后介绍的对 volatile 的一些特殊规定，就已经彻底肯定了java 程序中哪些内存访问操做在并发下是安全的；
【3】 对于volatile型变量的特殊规则
1）当一个变量定义为volatile后，它具有两种特性（characters）：
  • c1）保证此变量对全部线程的可见性，这里的可见性指：当一条线程修改了这个变量的值，新值对于其余线程来讲是能够当即得知的。而普通变量作不到这一点，其在线程间传递须要经过主内存来完成；（干货——这就是为何会出现数据的脏读）
  • c2）对于volatile变量的可见性，有一些误解： volatile变量对全部线程都是可见的，对volatile变量全部的写操做都能马上反应到其余线程中，即，volatile变量在各个线程中是一致的，全部基于 volatile变量的运算在并发下是安全的。上述语句中的错误在于并不能得出“基于 volatile变量的运算在并发下是安全的”这个结论。
2）虽然volatile变量在各个线程的工做内存中不存在一致性问题，但java里面的运算并不是原子操做，致使 volatile变量的运算在并发下同样是不安全的。
  • 2.1）看个荔枝：
  • [java]  view plain  copy
     
     在CODE上查看代码片派生到个人代码片
    1. public class VolatileTest {  
    2.     public static volatile int race = 0;  
    3.       
    4.     public static void increase() {  
    5.         race++;  
    6.     }  
    7.       
    8.     public static final int THREADS_COUNT = 20;  
    9.       
    10.     public static void main(String[] args) {  
    11.         Thread[] threads = new Thread[THREADS_COUNT];  
    12.         for (int i = 0; i < threads.length; i++) {  
    13.             threads[i] = new Thread(new Runnable() {  
    14.                 @Override  
    15.                 public void run() {  
    16.                     for (int j = 0; j < 10000; j++) {  
    17.                         increase();  
    18.                     }  
    19.                 }  
    20.             });  
    21.             threads[i].start();  
    22.         }  
    23.           
    24.         // 等待全部累计线程都ending  
    25.         while(Thread.activeCount() > 1) {  
    26.             Thread.yield();  
    27.         }  
    28.         System.out.println(race);  
    29.     }  
    30. }  
  • 对以上执行结果的分析（Analysis）：
    • A1）以上代码的正确输出结果是20000， 而执行的结果每次都不同，且都小于20000；
    • A2）用javap 反编译命令获得以下字节码，发现increase（）方法对应4条字节码指令（return指令不算）：

  • 对以上字节码的分析（Analysis）：
    • A1）当 getstatic指令 把 race 的值取到操做栈顶时，volatile关键字保证了 race的值在此时是正确的，可是在执行 iconst_1, iadd 这些指令的时候，其余线程可能已经把race 的值加大了，而在操做栈顶的值就变成了过时的数据，因此 putstatic 指令执行后就可能把较小的race 值同步回主内存中；
    • A2）客观上说，在这里使用 字节码来分析并发问题，不是很严谨。由于即便编译出来只有一条字节码指令，也不意味着执行这条指令就是一个原子操做。一条字节码指令也可能会转化成若干条本地机器码指令，此处使用 -XX:+PrintAssembly 参数输出反汇编来分析会更加严谨；（干货——由于即便编译出来只有一条字节码指令，也不意味着执行这条指令就是一个原子操做）
3）因为volatile变量只能保证可见性，在不符合如下两条规则的运算场景中，咱们仍然要经过加锁来保证原子性：
  • scene1）运算结果并不依赖变量的当前值，或者可以确保只有单一的线程修改变量的值；
  • scene2）变量不须要与其余的状态变量共同参与不变约束；
3.1）看个荔枝（使用volatile变量来控制并发）
[java]  view plain  copy
 
 在CODE上查看代码片派生到个人代码片
  1. // 使用volatile变量来控制并发  
  2. public class VolatileVariableTest {  
  3.     volatile boolean shutdownRequested; // volatile变量  
  4.       
  5.     public void shutdown() {  
  6.         shutdownRequested = true;  
  7.     }  
  8.     public void doWork() {  
  9.         while(!shutdownRequested) {  
  10.             // do sth.  
  11.         }  
  12.     }  
3.2）使用volatile变量的第二个语义是禁止指令重排序优化：普通变量仅仅会保证在该方法的执行过程当中全部依赖赋值结果的地方都能获取到正确的结果，而不能保证变量赋值操做的顺序与程序代码中的执行顺序一致。由于在一个线程的 方法执行过程当中没法感知到这点，这也就是java 内存模型中描述的所谓的 “线程内表现为串行的语义”； （干货——volatile能够禁止指令重排序优化）
[java]  view plain  copy
 
 在CODE上查看代码片派生到个人代码片
  1. // 指令重排序演示（伪代码）  
  2.     public void instruct_reorder() {  
  3.         Map configOptions;  
  4.         char[] configText;  
  5.         //  此变量必须为 volatile  
  6.         volatile boolean initialized = false;  
  7.           
  8.         // 假设如下代码在线程A 中执行  
  9.         // 模拟读取配置信息，当读取完成后将 initialized 设置为true 已通知其余线程配置可用  
  10.         configOptions = new HashMap();  
  11.         configText = readConfigFile(filename);  
  12.         processConfigOptions(configText, configOptions);  
  13.         initialized = true;  
  14.           
  15.         // 假设如下代码在线程B 中执行  
  16.         // 等待initialized 为true，表明线程A 已经把配置信息初始化完成  
  17.         while(!initialized) {  
  18.             sleep();  
  19.         }  
  20.         // 使用线程A 中初始化好的配置信息  
  21.         do_sth_with_config();  
  22.     }  
对以上代码的分析（Analysis）：
  • 若是定义initialized变量没有使用volatile修饰：就可能会因为指令重排序的优化，致使位于线程A 中最后一句代码“initialized=true”被提早执行；这样在线程B中使用配置信息的代码就可能出现错误，而volatile关键字则能够避免此类状况的发生；
3.3）再看个荔枝：（分析volatile关键字是如何禁止指令重排序优化的），如下代码是一段单例模式代码，能够观察加入 volatile和未加入volatile关键字时 所生成汇编代码的差异（如何得到JIT的汇编代码，参考4.2.7）
[java]  view plain  copy
 
 在CODE上查看代码片派生到个人代码片
  1. // 单例模式（分析volatile关键字是如何禁止指令重排序优化的）  
  2. public class Singleton {  
  3.     private volatile static Singleton instance;  
  4.       
  5.     public static Singleton getInstance() {  
  6.         if(instance == null) {  
  7.             synchronized (Singleton.class) { // 同步块  
  8.                 if(instance == null) {  
  9.                     instance = new Singleton();  
  10.                 }  
  11.             }  
  12.         }  
  13.         return instance;  
  14.     }  
  15.       
  16.     public static void main(String[] args) {  
  17.         Singleton.getInstance();  
  18.     }  
  19. }  
（这个反汇编荔枝待研究）
【3.4】对于long 和 double 型变量的特殊规则
1）java内存模型要求lock， unlock， read， load， assign， use，store，write这8个操做都具备原子性： 但对于64位的数据类型（long和double），在模型中特别定义了一条相对宽松的规定：容许虚拟机将没有被 volatile修饰的64位数据的读写操做划分为两次32位的操做来进行，即容许虚拟机实现选择能够不保证64位数据类型的load， store，read和write这4个操做的原子性，这点就是所谓的 long 和double 的非原子性协定；
2）这项宽松的规定所致使的problem：若是有多个线程共享一个并未声明为 volatile的long 或 double类型的变量，而且同时对它们进行读取和修改操做，那么某些线程可能会读取到一个既非原值，也不是其余线程修改值的表明了半个变量的数值；
3）不过这种读取到的“半个变量”的case很是罕见：由于java内存模型虽然容许虚拟机不把long 和 double 变量的读写实现成原子操做，但容许虚拟机选择把 这些操做实现为具备原子性的操做，并且还强烈建议虚拟机这样实现； （干货——不过这种读取到的“半个变量”的case很是罕见）
 
【3.5】原子性，可见性与有序性
0）intro： java内存模型是围绕着在并发过程当中如何处理原子性， 可见性和有序性这3个特征来创建的；
1）原子性：因为java内存模型来直接保证的原子性变量操做包括 read，load，assign，use，store和write，咱们大体认为基本数据类型的访问读写数据是具有原子性的。
  • 1.1）同步块——synchronized关键字：若是应用场景须要一个更大范围的原子性保证，java内存模型还提供了lock 和 unlock 操做来知足这些需求，尽管虚拟机没有把lock 和 unlock 操做直接开放给用户使用，可是却提供了更高层次的字节码指令 monitorenter 和 monitorexit 来隐式地使用这两个操做；
  • 1.2）这两个字节码指令反映到java代码中就是同步块——synchronized关键字：所以在synchronized块之间的操做也具有原子性；
2）可见性：可见性指当一个线程修改了共享变量的值，其余可以当即得知这个修改。
  • 2.1）java内存模型是经过在变量修改后将新值同步回主内存，在变量读取前从主内存刷新变量值这种依赖主内存做为传递媒介的方式来实现可见性的，不管是普通变量仍是volatile变量都是如此；
  • 2.2）普通变量与 volatile变量的区别是：volatile的特殊规则保证了新值能当即同步到主内存，以及每次使用前当即从主内存刷新；因此volatile保证了多线程操做时变量的可见性，普通变量则不能保证这一点；
  • 2.3）java还有两个关键字实现可见性： synchronized 和 final；
    • 2.3.1）同步块的可见性： 是由对一个变量执行unlock 操做前，必须先把此变量同步回主内存中；
    • 2.3.2）而final关键字的可见性：被final修饰的字段在构造器中一旦初始化完成，而且构造器没有把this 的引用传递出去，那在其余线程中就能看见final 字段的值。
    • 2.3.3）看个荔枝：
    • [java]  view plain  copy
       
       在CODE上查看代码片派生到个人代码片
      1. // final 可见性测试  
      2. public class FinalVisibilityTest {  
      3.     public static final int i;  
      4.       
      5.     public final int j;  
      6.       
      7.     static {  
      8.         i = 0;  
      9.         // do sth  
      10.     }  
      11.     {  
      12.         // 也能够选择在构造函数中初始化  
      13.         j = 0;  
      14.         // do sth  
      15.     }  
      16. }     
  • 对以上代码的分析（Analysis）：变量i 和 j 都具有可见性，它们无须同步就能被其余线程正确访问；
3）有序性
  • 3.1）java程序中自然的有序性总结为一句话：若是在本线程内观察，全部的操做都是有序的；若是在一个线程中观察另外一个线程，全部的操做都是无序的。前半句是指： 线程内表现为串行的语义，后半句是指：指令重排序现象和工做内存与主内存同步延迟现象；
  • 3.2）volatile和 synchronized关键字保证了线程间操做的有序性：volatile关键字自己就包含了禁止指令重排序的语义，而synchronized则是由 一个变量在同一时刻只容许一条线程对其进行lock 操做这条规则得到的，这条规则决定了持有同一个锁的两个同步块只能串行地进入；
【3.6】先行发生原则
1）先行发生原则定义：先行发生是 java内存模型中定义的两项操做之间的偏序关系，若是说操做A 先行发生于操做B，其实就是说在发生操做B以前，操做A产生的影响能被操做B观察到， 影响包括 修改了内存中共享变量的值，发送了消息，调用了方法等； （干货——先行发生原则定义）
2）看个荔枝（如何理解 “影响包括 修改了内存中共享变量的值，发送了消息，调用了方法等”）
[java]  view plain  copy
 
 在CODE上查看代码片派生到个人代码片
  1. // 先行发生 原则  
  2. public class AheadOccurTest {  
  3.     int i = 0;  
  4.     int j = 0;  
  5.       
  6.     public void test() {  
  7.         // 如下操做在线程A中执行  
  8.         i = 1;  
  9.         // 如下操做在线程 B 中执行  
  10.         j = i;  
  11.         // 如下操做在线程 C 中执行  
  12.         i = 2;  
  13.     }  
  14. }  
对以上代码的分析（Analysis）：线程C 出如今 线程A 和 B之间， 但线程C 和 B 并无先行发生关系，那j的值 会是多少，答案是不肯定的；
3）下面是java内存模型下一些自然的先行发生关系，这些先行发生关系无须任何同步器协助就已经存在，能够在编码中直接使用：
  • 3.1）程序次序规则：在一个线程内，按照程序代码顺序，书写在前面的操做先行发生于书写在后面的操做；准确地说，应该是控制流顺序；
  • 3.2）管程锁定规则：一个unlock操做先行发生于后面对同一个锁的lock操做；这里必须强调的是同一个锁，然后面是指时间上的前后顺序；
  • 3.3）volatile变量规则：对一个volatile变量的写操做先行发生于后面对这个变量的读操做，这里的后面是指时间上的前后顺序；
  • 3.4）线程启动规则：Thread对象的start() 方法先行发生于此线程的每个动做；
  • 3.5）线程终止规则：线程中的全部操做都先行发生于对此线程的终止检测，能够经过Thread.join() 方法结束，Thread.isAlive() 的返回值等手段检测到线程已经终止运行；
  • 3.6）线程中断规则：对线程interrupt() 方法的调用先行发生于被中断线程的代码检测到中断事件的发生，能够经过 Thread.interrrupted() 方法检测到是否有中断发生；
  • 3.7）对象终结规则：一个对象的初始化完成先行发生于它的finalize() 方法的开始；
  • 3.8）传递性：若是操做A 先行发生于操做B， 操做B 先行发生于操做C，那就能够得出操做A 先行发生于 操做C的结论；
4）看个荔枝：如何使用这些规则去断定操做间是否具有顺序性，对于读写共享变量的操做来讲，就是线程是否安全；
[java]  view plain  copy
 
 在CODE上查看代码片派生到个人代码片
  1. // 利用先行发生 原则  
  2. // 断定操做间是否具有顺序性，对于读写共享变量的操做来讲，就是线程是否安全  
  3. public class AheadOccurTest2 {  
  4.     private int value = 0;  
  5.       
  6.     public void setValue(int value) {  
  7.         this.value = value;   
  8.     }  
  9.   
  10.     public int getValue() {  
  11.         return value;  
  12.     }  
  13.       
  14.     Integer i = 0;  
  15. }     
对以上代码的分析（Analysis）：
  • A1）problem：假设线程A 先调用了 setValue(1)， 以后线程B 调用了同一个对象的getValue() ，那么线程B 收到的value是什么？
  • A2）能够断定：尽管线程A在操做时间上先于线程B， 可是没法肯定线程B 中“getValue()” 方法的返回结果，换句话说，这里面的操做不是线程安全的；
  • A3）solution：咱们至少有两种简单的解决方案：
    • solution1）要么把getter 和  setter方法都定义为 synchronized方法，这样就能够套用管程锁定规则；
    • solution2）要么把value定义为 volatile变量，因为setter方法对value的修改不依赖于 value的原值，知足volatile关键字使用场景，这样就能够套用volatile变量规则来实现先行发生关系；
  • A4）得出结论：一个操做时间上的先发生 不表明这个操做会是先行发生，那若是一个操做先行发生是否就能推导出这个操做一定是 时间上的先行发生呢？ （显然推导不出来）。一个典型的荔枝就是屡次提到的“指令重排序”。
    • A4.1）看个荔枝：
    • [java]  view plain  copy
       
       在CODE上查看代码片派生到个人代码片
      1. // 如下操做在同一个线程中执行  
      2. int i = 1;  
      3. int j = 2;  
    • 对上述代码的分析（Analysis）： 根据程序次序规则， int i = 1 的操做先行发生于 int j =2，但 int j = 2 彻底可能先被处理器执行，这并不影响先行发生原则的正确性；
  • Conclusion）以上两个实例得出结论：时间前后顺序与先行发生原则之间基本没有太大的关系，因此咱们衡量并发安全问题的时候不要受到时间顺序的干扰，一切必须以先行发生原则为准；
【4】java 与线程
【4.1】线程的实现
0）intro
  • 0.1）线程是比进程更轻量级的调度执行单位： 线程的引入，能够把一个进程的资源分配和执行调度分开，各个线程既能够共享进程资源（内存地址，文件IO等），又能够独立调度（线程是CPU 调度的基本单位）；
  • 0.2）线程实现的3种方式：使用内核线程实现，使用用户线程实现，使用用户线程加轻量级进程混合实现（干货——线程实现的3种方式：使用内核线程实现+使用用户线程实现+使用用户线程和轻量级进程混合实现）

1）使用内核线程实现
  • 1.1）内核线程（KLT，Kernel-Level Thread）：就是直接由操做系统内核（下称内核）支持的线程，这种线程由内核来完成线程切换，内核经过操纵调度器对线程进行调度，并负责将线程的任务映射到各个处理器上。（干货——内核线程和轻量级进程的定义）
  • 1.2）程序通常不会直接去使用内核线程，而是去使用内核线程的一种高级接口——轻量级进程（Light Weight Process, LWP）：轻量级进程就是咱们一般意义上讲的线程，因为每一个轻量级线程都由一个内核线程支持，所以只有先支持内核线程，才能有轻量级进程。这种轻量级进程与内核线程间1:1 的关系称为一对一的线程模型，以下图所示：（干货——引入轻量级进程）

  • 1.3）轻量级进程有局限性：
    • 1.3.1）首先：因为是基于内核线程实现的，因此各类线程操做，如建立，析构及同步，都须要进行系统调用， 而系统调用的代价相对较高，须要在用户态和内核态中来回切换；
    • 1.3.2）其次：每一个轻量级进程都须要有一个内存线程的支持，所以轻量级进程要消耗必定的内核资源（如内核线程的栈空间），所以一个系统支持轻量级进程的数量是有限的；
2）使用用户线程实现（已经被Deprecated）
3）使用用户线程加轻量级进程混合实现
  • 3.1）在该实现方式下，既存在用户线程，也存在轻量级进程；
  • 3.2）用户线程仍是彻底创建在用户空间中：所以用户线程的建立，切换，析构等操做依然廉价，而且能够支持大规模的用户线程并发；
  • 3.3）操做系统提供支持的轻量级进程则做为用户线程和内核线程之间的桥梁：这样可使用内核提供的线程调度功能及处理器映射，而且用户线程的系统调用要经过轻量级线程来完成，大大下降了整个进程被彻底阻塞 的风险；（干货——操做系统提供支持的轻量级进程则做为用户线程和内核线程之间的桥梁）
  • 3.4）在这种混合模式中：用户线程与轻量级进程的数量比是不定的，即为 N：M 的关系，以下图所示， 这种就是多对多的线程模型；
【4.2】java线程调度
1）线程调度定义：是指系统为线程分配处理器使用权的过程，主要调度方式有：协同式线程调度 和 抢占式线程调度； （干货——线程调度定义 + 主要调度方式）
（干货——请注意协同式线程调度和抢占式线程调度的区别）
2）使用协同式线程调度的多线程系统：线程的执行时间由线程自己来控制，线程把本身的工做执行完之后，要主动通知系统切换到另一个线程上；
  • 2.1）其好处是：实现简单，并且因为线程要把本身的事情干完后才会进行线程切换，切换操做读线程本身是可知的，因此没有什么线程同步的问题；
  • 2.2）其坏处是：线程执行时间不可控制，甚至若是一个线程编写有问题，一直不告诉系统进行线程切换，那么程序就会一直阻塞在那里；
3）使用抢占式线程调度的多线程系统：那么每一个线程将由系统来分配执行时间，线程的切换不禁线程自己来决定；
  • 3.1）java使用的方式就是 抢占式线程调度方式；
  • 3.2）虽然java 线程调度是系统自动完成的： 但咱们仍是能够建议系统给某些线程多分配一点执行时间，另一些线程则能够少分配一点——这项操做能够经过设置线程优先级来完成；（干货——设置java 线程优先级）
  • 3.3.）不过线程优先级并非太靠谱：由于java的线程是经过映射到系统的原生线程上来实现的，因此线程调度最终仍是取决于 操做系统；虽然如今不少os 都提供了线程优先级，但不见得和 能与 java线程的优先级一一对应；如 Solaris中有 2^32 种优先级，而windows只有7种 ；（干货——java的线程优先级并非太靠谱）
  • 3.4）下表显示了 java线程优先级 与 windows 线程优先级之间的对应关系：
补充-Complementary）：
  • C1）上文说到的“java线程优先级并非太靠谱”，不只仅是在说一些平台上不一样的优先级实际会变得相同这一点，还有其余case 让咱们不能太依赖优先级：优先级可能会被系统自行改变。（干货——优先级可能会被系统自行改变）
  • C2）如，在windows 中存在一个称为 “优先级推动器”的功能，做用是 当系统发现一个线程执行得特别勤奋的话，可能会越过线程优先级去为它分配执行时间；
【4.3】状态转换
1）java定义了6种状态（status）：（干货——java定义了6种线程状态）
  • 1.1）新建（New）：建立后还没有启动的线程处于这个状态；
  • 1.2）运行（Runnable）：Runable包括了os 线程状态中的 Running 和 Ready，也就是处于 此状态的线程有可能正在执行，也有可能正在等待着CPU 为它分配执行时间；
  • 1.3）无限期等待（Waiting）：处于这种状态的线程不会被分配CPU执行时间，它们要等待被其余线程显式的唤醒。如下方法会让线程陷入无限期的等待状态（methods）：
    • m1）没有设置Timeout参数的Object.wait()方法；
    • m2）没有设置Timeout参数的 Thread.join() 方法；
    • m3）LockSupport.park() 方法；
  • 1.4）限期等待（Timed Waiting）：处于这种状态的线程也不会被分配CPU 执行时间，不过无需等待被其余线程显式唤醒，在必定时间以后，它们会由系统自动唤醒。如下方法会让线程进入限期等待状态（methods）：
    • m1）Thread.sleep() 方法；
    • m2）设置了Timeout参数的Object.wait()方法；
    • m3）设置了Timeout参数的 Thread.join() 方法；
    • m4）LockSupport.parkNanos() 方法；
    • m5）LockSupport.parkUntil() 方法；
  • 1.5）阻塞（Blocked）：线程被阻塞了， 阻塞状态与等待状态的区别是：阻塞状态在等待着获取到一个排他锁，这个事件将在另一个线程放弃这个锁的时候发生；而等待状态则是在等待一段时间，或者唤醒动做的发生。在程序等待进入同步区域的时候，　线程将进入这种状态；
  • 1.6）结束（Terminated）：已经终止线程的线程状态，线程已经结束执行；
2）以上6种状态会相互转换，转换关系以下图所示：
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程