java内存模型与线程

<h1>
    <span class="link_title"><a href="/listslim1/article/details/51420054">
    java内存模型与线程            
    </a></span>
</h1>

    <div class="article_manage clearfix">
    <div class="article_r">
        <span class="link_postdate">2016-05-15 23:20</span>
        <span class="link_view" title="阅读次数">1236人阅读</span>
        <span class="link_comments" title="评论次数"> <a href="#comments" onclick="_gaq.push(['_trackEvent','function', 'onclick', 'blog_articles_pinglun'])">评论</a>(0)</span>
        <span class="link_collect tracking-ad" data-mod="popu_171"> <a href="javascript:void(0);" onclick="javascript:collectArticle('java%e5%86%85%e5%ad%98%e6%a8%a1%e5%9e%8b%e4%b8%8e%e7%ba%bf%e7%a8%8b','51420054');return false;" title="收藏">收藏</a></span>
         <span class="link_report"> <a href="#report" onclick="javascript:report(51420054,2);return false;" title="举报">举报</a></span>

    </div>
</div>
<div class="embody" style="display:none" id="embody">
    <span class="embody_t">本文章已收录于：</span>
    <div class="embody_c" id="lib" value="{&quot;err&quot;:0,&quot;msg&quot;:&quot;ok&quot;,&quot;data&quot;:[]}"></div>
</div>
<style type="text/css">        
        .embody{
            padding:10px 10px 10px;
            margin:0 -20px;
            border-bottom:solid 1px #ededed;                
        }
        .embody_b{
            margin:0 ;
            padding:10px 0;
        }
        .embody .embody_t,.embody .embody_c{
            display: inline-block;
            margin-right:10px;
        }
        .embody_t{
            font-size: 12px;
            color:#999;
        }
        .embody_c{
            font-size: 12px;
        }
        .embody_c img,.embody_c em{
            display: inline-block;
            vertical-align: middle;               
        }
         .embody_c img{               
            30px;
            height:30px;
        }
        .embody_c em{
            margin: 0 20px 0 10px;
            color:#333;
            font-style: normal;
        }
</style>
<script type="text/javascript">
    $(function () {
        try
        {
            var lib = eval("("+$("#lib").attr("value")+")");
            var html = "";
            if (lib.err == 0) {
                $.each(lib.data, function (i) {
                    var obj = lib.data[i];
                    //html += '<img src="' + obj.logo + '"/>' + obj.name + "&nbsp;&nbsp;";
                    html += ' <a href="' + obj.url + '" target="_blank">';
                    html += ' <img src="' + obj.logo + '">';
                    html += ' <em><b>' + obj.name + '</b></em>';
                    html += ' </a>';
                });
                if (html != "") {
                    setTimeout(function () {
                        $("#lib").html(html);                      
                        $("#embody").show();
                    }, 100);
                }
            }      
        } catch (err)
        { }
        
    });
</script>
  <div class="category clearfix">
    <div class="category_l">
       <img src="http://static.blog.csdn.net/images/category_icon.jpg">
        <span>分类：</span>
    </div>
    <div class="category_r">
                <label onclick="GetCategoryArticles('6230108','listslim1','top','51420054');">
                    <span onclick="_gaq.push(['_trackEvent','function', 'onclick', 'blog_articles_fenlei']);">java虚拟机<em>（5）</em></span>
                  <img class="arrow-down" src="http://static.blog.csdn.net/images/arrow_triangle _down.jpg" style="display:inline;">
                  <img class="arrow-up" src="http://static.blog.csdn.net/images/arrow_triangle_up.jpg" style="display:none;">
                    <div class="subItem">
                        <div class="subItem_t"><a href="http://blog.csdn.net/listslim1/article/category/6230108" target="_blank">作者同类文章</a><i class="J_close">X</i></div>
                        <ul class="subItem_l" id="top_6230108">                            
                        </ul>
                    </div>
                </label>                    
    </div>
</div>
<script type="text/javascript" src="http://static.blog.csdn.net/scripts/category.js"></script>  

目录(?)[+]

1. java内存模型
1. 主内存与工作内存
2. 内存间交互操作
3. 对于volatile型变量的特殊规则
4. 原子性可见性与有序性
5. 先行发生原则
2. java与线程
1. 线程的实现
2. java线程调度
3. 状态转换
3. 线程安全
1. java语言中的线程安全
2. 线程安全的实现方法
4. 优化锁
1. 自旋锁与自适应自旋
2. 锁消除
3. 锁粗化
4. 轻量级锁
5. 偏向锁

java内存模型

主内存与工作内存

    Java内存模型规定了所有的变量都存储在主内存中（此处的主内存仅仅指虚拟机内存），每条线程还有自己的工作内存，线程的工作内存中保存了被线程使用到的变量的主内存副本拷贝，线程对变量的所有操作都必须在工作内存中进行，而不能直接读写主内存中的变量。不同线程之间也无法直接访问对方工作内存中的变量，线程间变量值的传递均需要通过主内存来完成，线程、主内存、工作内存三者的交互关系如下

内存间交互操作

    Java内存模型中定义了一下8种操作来完成主内存与工作内存之间的同步，虚拟机实现时必须保证下面的每一种操作都是原子的，不可再分的（对于double和long类型的变量，load store read和write操作在某些平台上允许有例外）
    Lock（锁定）：作用于主内存的变量，它把一个变量表示为一个线程独占的状态；
    Unlock（解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定；
    Read（读取）：作用于主内存的变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用。
    Load（载入）：作用于工作内存的变量，它把read操作从主内存中得到的变量值放入工作内存的变量副本中。
    Use（使用）：作用于工作内存的变量，它把工作内存中一个变量的值传递给执行引擎，每当虚拟机遇到一个需要使用到变量的值的字节码指令时将会执行这个操作。
    Assign（赋值）：作用于工作内存的变量，它把一个从执行引擎接收到的值赋给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指定时执行这个操作。
    Store（存储）：作用于工作内存的变量，它把工作内存中一个变量的值传送到主内存中，以便随后的write操作使用。
    Write（写入）：作用于主内存的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中。
    变量从主内存复制到工作内存：read -> load
    变量从工作内存同步到主内存：store -> write

对于volatile型变量的特殊规则

    关键字volatile是java虚拟机提供的最轻量级的同步机制。当一个变量定义为volatile之后，它将具备两种特性，
    第一是保证此变量对所有线程的可见性，即当某一线程修改了这个变量的值，其他线程可以立即得知。但java里面的运算并非原子操作，导致volatile变量的运算在并发下一样是不安全的，例如i++操作，当getstatic指令把i值取到操作栈顶时，volatile关键字保证了i值是正确的，但是执行iconst_1、iadd这些指令时，其他线程可能已经把i的值加大了，而在操作栈顶的值就变成了过期的数据，所以putstatic指令执行后就可能把较小的i值同步回主内存之中了。也就是说，volatile只能保证变量在各线程之间的可见性，但不能保证对其操作的原子性，也就是说不具有同步性。在不符合以下两条规则的运算场景中，我们仍然要通过加锁来保证原子性，
    运算结果并不依赖变量的当前值，或者能够确保只有单一的线程修改变量的值；
    变量不需要与其他的状态变量共同参与不变约束。
    而像如下代码所示的场景就很适合使用volatile变量来控制并发，当shutdown()方法被调用时，能保证所有线程中执行的doWork()方法都立即停下来。

volatile boolean shutdownRequested;
public void shutdown() {
    shutdownRequested = true;
}
public void doWork() {
    while(!shutdownRequested) {
        // do stuff
    }
}

volatile boolean shutdownRequested;
public void shutdown() {
    shutdownRequested = true;
}
public void doWork() {
    while(!shutdownRequested) {
        // do stuff
    }
}

    使用volatile变量的第二个语义是禁止指令重排列优化，普通的变量仅仅会保证在该方法的执行过程中所有依赖赋值结果的地方都能获取到正确的结果，而不能保证变量赋值操作的顺序与程序代码中的执行顺序一致。因为在一个线程的方法执行过程中无法感知到这点，也就是java内存模型中描述的所谓的“线程内表现为串行的语义”。

原子性、可见性与有序性

    原子性，基本类型的操作可以认为都具有原子性，对于其他更大范围的原子性保证，java提供了Synchronized关键字来实现同步快，从而保证操作的原子性。
可见性，是指当一个线程修改了共享变量的值，其他线程能够立即得知这个修改。Java内存模型是通过在变量修改后将新值同步回主内存，在变量读取前从主内存刷新该变量值这种依赖主内存作为传递媒介的方式来实现可见性的。
    除了volatile之外，java还有两个关键字能够实现可见性，即Synchronized和final。同步块的可见性是由“对一个变量执行unlock操作前，必须先把此变量同步回主内存中”这条规则获得，而final关键字的可见性是指：被final修饰的字段在构造器中一旦初始化完成，并且构造器没有把this的引用传递出去，那在其他线程中就能看见final字段的值。
    有序性。如果在本线程内观察，所有的操作都是有序的；如果在一个线程中观察另一个线程，所有的操作都是无序的。前半句是指“线程内表现为串行的语义”，后半句是指“工作内存和主内存同步延迟”现象。
    Java语言提供了volatile和Synchronized两个关键字来保证线程之间操作的有序性，volatile关键字本身就包含了禁止指令重排序的语义，而Synchronized则是由“一个变量在同一时刻只允许一条线程对其进行lock操作”这条规则获得的，这条规则决定了持有同一个锁的两个同步块只能串行地进入。

先行发生原则

    先行发生是指java内存模型中定义的两项操作之间的偏序关系，如果说操作A先行发生于操作B，其实就是说在发生操作B之前，操作A产生的影响能被操作B观察到，“影响”包括修改了内存中共享变量的值、发送了消息、调用了方法等。Java内存模型中的先行关系包括：
    程序次序规则：在一个线程内，按照程序代码顺序，书写在前面的操作先行发生于书写在后面的操作。
    管程锁定规则：一个unlock操作先行发生于后面对同一个锁的lock操作。这里必须强调是同一个锁，而“后面”是指时间上的先后顺序。
    Volatile变量规则：对于一个volatile变量的写操作先行发生于后面对这个变量的读操作。
    线程启动规则：Thread对象的start()方法先行发生于此线程的每一个动作
    线程终止规则：线程中的所有操作都先行发生于对此线程的终止检测，我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值等手段检测到线程已经终止执行。
    线程中断规则：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生，可以通过Thread.interrupted()方法检测到是否有中断发生。
    对象终结规则：一个对象的初始化完成（构造函数执行结束）先行发生于它的finalize()方法的开始。
    传递性：如果操作A先行发生于操作B，操作B先行发生于操作C，那就可以得出操作A先行发生于操作C的结论。

java与线程

线程的实现

    实现线程主要有3种方式：使用内核线程实现、使用用户线程实现和使用用户线程加轻量级进程混合实现。
    内核线程就是直接由操作系统内核支持的线程，这种线程由内核来完成线程切换，内核通过操纵调度器对线程进行调度，并负责将线程的任务映射到各个处理器上。程序一般不会直接去使用内核线程，而是去使用内核线程的一种高级接口——轻量级进程。轻量级进程具有它的局限性：首先由于是基于内核线程实现的，所以各种线程操作，如创建、析构及同步，都需要进行系统调用。而系统调用的代价相对较高，需要在用户态和内核态中来回切换。其次，每个轻量级进程都需要有一个内核线程的支持，因此轻量级进程要消耗一定的内核资源（如内核线程的栈空间），因此一个系统支持轻量级进程的数量是有限的。
    用户线程的建立、同步、销毁和调度完全在用户态中完成，不需要内核的帮助。使用用户线程的优势在于不需要系统内核支援，劣势也在于没有系统内核的支援，所有的线程操作都需要用户程序自己处理，从而使得这种方式实现的程序一般都比较复杂。
    使用用户线程加轻量级进程混合实现，既存在用户线程，也存在轻量级进程。用户线程还是完全建立在用户控件中，因此用户线程的创建、切换、析构等操作依然廉价，并且可以支持大规模的而用户线程并发。而操作系统提供支持的轻量级进程则作为用户线程和内核线程之间的桥梁，这样可以使用内核提供的线程调度功能及处理器映射，并且用户线程的系统调用要通过轻量级线程来完成，大大降低了整个进程被完全阻塞的风险。
    Java线程的实现，对于Sun JDK来说，Windows版和Linux都是一对一的线程模型实现的，一条java线程就映射到一条轻量级进程之中。在Solaris平台中，提供了两个虚拟机参数来指定使用哪种线程模型。

java线程调度

    线程调度是指系统为线程分配处理器使用权的过程，主要调度方式有两种，分别是协同式线程调度和抢占式线程调度。
    如果使用协同式线程调度，线程的执行时间是由线程本身来控制，线程把自己的工作执行完了之后，要主动通知系统切换到另外一个线程上。其最大的好处是实现简单，而且由于线程要把自己的事情干完后才会进行线程切换，切换操作对线程自己是可知的，所以没有什么线程同步的问题。它的坏处也很明显：线程执行时间不可控制，甚至如果一个线程编写有问题，一直不告知系统进行线程切换，那么程序就会一直阻塞在哪里。
    如果使用抢占式调度的多线程系统，那么每个线程将由系统来分配执行时间，线程的切换不由线程本身来决定。在这种实现线程调度的方式下，线程的执行时间是系统可控的，也不会有一个线程导致整个进程阻塞的问题。Java使用的线程调度方式就是抢占式调度。

状态转换

    Java语言定义了5种线程状态，在任意一个时间点，一个线程只能有且只有一种状态，
    新建（New）：创建后尚未启动的线程处于这种状态
    运行（Runnable）：Runnable包括了操作系统线程状态中的Running和Ready，也就是处于此状态的线程有可能正在执行，也有可能正在等待这CPU为它分配执行时间。
    无限期等待（Waiting）：处于这种状态的线程不会被分配CPU执行时间，它们要等待被其他线程显式地唤醒。以下方法会让线程陷入无限期的等待状态，
    没有设置Timeout参数的Object.wait()方法；
    没有设置Timeout参数的Thread.join()方法；
    LockSupport.park()方法。
    限期等待（Timed Waiting）：处于这种状态的线程也不会被分配CPU执行时间，不过无须等待被其他线程显示地唤醒，在一定时间之后它们会由系统自动唤醒，以下方法会让线程进入限期等待状态：
    Thread.sleep方法
    设置了TImeout参数的Object.wait()方法
    设置了Timeout参数的Thread.join()方法
    LockSupport.parkNanos()方法
    LockSupport.parkUntil()方法
    阻塞（Blocked）：线程被阻塞了，阻塞与等待的区别是，阻塞在等待这获取到一个排他锁，这个事件将在另外一个线程放弃这个锁的时候发生；而等待则是在等待一段时间，或者唤醒动作的发生。在程序等待进入同步区域的时候，线程将进入这种状态。
    结束（Terminated）：已终止线程的线程状态，线程已经结束执行。

线程安全

    当多个线程访问一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行，也不需要进行额外的同步，或者在调用方进行任何其他的协调操作，调用这个对象的行为都可以获得正确的结果，那这个对象是线程安全的。

java语言中的线程安全

    不可变
    只要一个不可变的对象被正确地构建出来（没有发生this引用逃逸的情况），那其外部的可见状态永远也不会改变。不可变带来的安全性是最简单和最纯粹的。例如String类的对象，它是一个典型的不可变对象，我们调用它的subString(),replace()等方法都不会影响它原来的值，只会返回一个新构造的字符串对象。
    绝对线程安全
    绝对的线程安全是指一个类要达到“不管运行时环境如何，调用者都不需要任何额外的同步措施”。通常需要付出很大的，甚至有时候是不切实际的代价。在java API中标注自己是线程安全的类，大多数都不是绝对的线程安全。例如Vector，是一个线程安全的容器，因为其add()、get()和size()方法都是被Synchronized修饰的，尽管这样效率很低，但确实是安全的。但是即使所有的方法都被修饰成同步，也不意味着调用它的时候永远都不再需要同步手段了。例如，当一个线程刚好删除了序号为i的元素，而另一个线程再遍历vector的元素就会抛出一个ArrayIndexOutOfBoundsException。在这种一个线程做delete，另一个线程做get操作时，两个操作本身需要进行同步。
    相对线程安全
    相对的线程安全就是我们通常意义上所讲的线程安全，它需要保证对这个对象单独的操作是线程安全的，我们在调用的时候不需要做额外的保障措施，但是对于一些特定顺序的连续调用，就肯能需要在调用端使用额外的同步手段来保证调用的正确性。在java语言中，大部分的线程安全类都属于这种类型，例如Vector、HashTable、Collections的synchronizedCollection()方法包装的集合等。
    线程兼容
    线程兼容是指对象本身并不是线程安全的，但是可以通过在调用段正确地使用同步手段来保证对象在并发环境中可以安全地使用。Java API中大部分的类都是属于线程兼容的，如ArrayList和HashMap。
    线程对立
    线程对立是指无论调用端是否采用了同步措施，都无法在多线程环境中并发使用的代码。例如Thread类的suspend()和resume()方法，如果有两个线程同时持有一个线程对象，一个尝试去中断线程，另一个尝试去恢复线程，如果并发进行的话，无论调用时是否进行了同步，目标线程都是存在死锁风险的。如果suspend()中断的线程就是即将要执行resume()的那个线程，那就肯定要产生死锁了。

线程安全的实现方法

    1. 互斥同步
    互斥同步是常见的一种并发正确性保障手段，同步是指在多个线程并发访问共享数据时，保证共享数据在同一个时刻只被一个线程使用。而互斥是实现同步的一种手段，临界区，互斥量和信号量都是主要的互斥实现方式。互斥是因，同步是果；互斥是方法，同步是目的。
    在java中，最基本的互斥同步手段就是Synchronized关键字，它经过编译之后，会在同步块的前后分别行程monitorenter和monitorexit这两个字节码指令，这两个字节码都需要一个reference类型的参数来指明要锁定和解锁的对象。如果java程序中的Synchronized明确指定了对象参数，那就是这个对象的reference；如果没有明确指定，那就是根据    Synchronized修饰的是实例方法还是类方法，去取对应的对象实例或者Class对象来作为锁对象。
    在执行monitorenter指令时，首先要尝试获取对象的锁。如果这个对象没被锁定，或者当前线程已经拥有了那个对象的锁，把锁的计数器加1，相应的，在执行monitorexit指令时会将锁计数器减1，当计数器为0时，锁就被释放。如果获取对象锁失败，那当前线程就要阻塞等待，直到对象锁被另外一个线程释放为止。
    Synchronized同步块对同一条线程来说是可重入的，不会出现自己把自己锁死的问题。其次，同步块在已进入的线程执行完之前，会阻塞后面其他线程的进入。由于java的线程是映射到操作系统的原生线程之上的，如果要阻塞或唤醒一个线程，都需要操作系统来帮忙完成，这就需要从用户态转换到核心态中，因此状态转移需要耗费很多的处理器时间。对于代码简单的同步快，如Synchronized修饰的getter()和setter()方法，状态转换消耗的时间可能比用户代码执行的时间还要长。所以Synchronized是java语言中一个重量级的操作。虚拟机本身也会进行一些优化，比如在通知操作系统阻塞线程之前加入一段自旋等待过程，避免频繁地切入到核心态之中。
    除了Synchronized之外，还可以使用重入锁ReentrantLock来实现同步。在基本用法上，ReentrantLock与Synchronized很相似，他们都具备一样的线程重入特性，只是代码写法上有点区别，前者为API层面的互斥锁，lock和unlock方法配合try/finally，后者表现为原生语法层面的互斥锁。相比Synchronized，ReentrantLock增加了一些高级功能，例如等待可中断、可实现公平锁，以及锁可以绑定多个条件。
    等待可中断是指当前持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情，可中断特性对处理执行时间非常长的同步块很有帮助。
    公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来一次获得锁。
    锁绑定多个条件是指一个ReentrantLock对象可以同时绑定多个Condition对象，而在Synchronized，锁对象的wait()和notify()或者notifyAll()方法可以实现一个隐含的条件，如果要和多于一个的条件关联的时候，就不得不额外地添加一个锁。
    2. 非阻塞同步（无锁）
    互斥同步最主要的问题就是进行线程阻塞和唤醒所带来的性能问题，因此这种同步也称为阻塞同步，互斥同步属于一种悲观的并发策略。相反，我们有另一个选择是基于冲突检测的乐观并发策略，就是先进行操作，如果没有其他线程争用共享数据，那操作就成功了；如果共享数据有争用，产生了冲突，那就再采用其他补偿措施（例如不断地重试，直到成功为止），这种乐观的并发策略的许多实现都不需要把线程挂起，因此这种同步操作称为非阻塞同步。这种实现是基于硬件指令的实现，因为我们需要操作和冲突检测这两个步骤具备原子性，如果再使用互斥同步来保证就时区意义了，所以只能靠硬件来完成这件事情，硬件保证一个从语义上看起来需要多次操作的行为只通过一条处理器指令就能完成。例如：Compare-and-Swap，CAS。
    CAS指令需要有3个操作数，分别是内存位置V、旧的预期值A和新值B。CAS指令执行时，当且仅当V符合旧预期值A时，处理器用新值B更新V的值，否则它就不执行更新，但是无论是否更新了V的值，都会返回V的旧值，上述的处理过程是一个原子操作。
    CAS无法涵盖互斥同步的所有使用场景，并且CAS从语义上来说并不是完美的，存在这样一个逻辑漏洞：如果一个变量V初次读取的时候是A值，并且在准备复制的时候检查到它仍然是A值，那我们也无法说明它的值没有被其他线程改变过！这个漏洞称为CAS操作的“ABA”问题。这种问题可以通过控制变量的版本来保证CAS的正确性，但是大部分情况下ABA问题不会影响程序并发的正确性，如果需要解决ABA问题，改用传统的互斥同步可能会比原子类更高效。
    类似CAS指令还有：测试并设置 Test-and-Set 获取并增加 Fetch-and-Increment 交换 Swap 加载链接/条件存储 Load-Linked/Store-Conditional LL/SC
    Java7中的AtomicInteger, AtomicLong java8中的LongAdder
    3. 无同步方案
    如果一个方法本来就不涉及共享数据，那它自然就无需任何同步措施去保证正确性，因此会有一些代码天生就是线程安全的，例如
    1） 可重入代码
    这种代码可以在代码执行的任何时刻中断它，转而去执行另外一段代码（包括递归调用它本身），而在控制权返回后，原来的程序不会出现任何错误。所有的可重入代码都是线程安全的，但是并非所有的线程安全的代码都是可重入的。可重入代码有一些共同特征，例如不依赖存储在堆上的数据和公用的系统资源、用到的状态量都由参数中传入，不调用非可重入的方法等。一个简单的判断原则是：如果一个方法，它的返回结果是可以预测的，只要输入了相同的数据，就都能返回相同的结果，那它就满足可重入性要求。
    2） 线程本地存储
    如果一段代码中所需要的数据必须与其他代码共享，那就看看这些共享数据的代码是否能保证在同一个线程中执行。如果可以，就把共享数据的可见范围限制在同一个线程之内，这样无需同步也能保证线程之间不出现数据争用的问题。
    Java语言中，一个变量要被多线程访问，可以使用volatile关键字申明；如果一个变量要被某个线程独享，可以使用ThreadLocal变量。每一个线程的Thread对象中都有一个ThreadLocalMap对象，这个对象存储了一组以ThreadLocal.threadLocalHashCode为key，以本地线程变量为value的键值对，ThreadLocal对象就是当前线程的 ThreadLocalMap的访问入口，每一个ThreadLocal对象都包含了一个独一无二的threadLocalHashCode值，使用这个值就可以在线程K-V值对中找回对应的本地线程变量。

优化锁

    在java虚拟机的实现中，每个对象都有一个对象头，用于保存对象的系统信息。对象头中有一个称为Mark Word的部分，它是实现锁的关键，可以存放对象的哈细值、对象年龄、锁的指针等信息。
    锁在引用层的优化思路有：减少锁持有时间，减小锁粒度（例如ConcurrentHashMap的分段锁），锁分离（LinkedBlockingQueue的take和put是两个锁），锁粗化。

自旋锁与自适应自旋

    互斥同步对性能的影响是阻塞的实现，挂起线程和恢复线程的操作都需要转入内核态中完成。而在许多应用上，共享数据的锁定状态只会持续很短的一段时间，为了这段时间去挂起和恢复线程并不值得。如果有一个以上的处理器，能让两个或以上的线程同时并行执行，我们可以让后面请求锁的那个线程“稍微等一下”，但不放弃处理器的执行时间，看看持有锁的线程是否很快就会释放锁。为了让线程等待，我们只需让线程执行一个忙循环（自旋），这项技术就是所谓的自旋锁。
自旋等待不能代替阻塞，且不说对处理器数量的要求，自旋等待本身虽然避免了线程切换的开销，但它是要占用处理器时间的，因此如果锁被占用的时间很短，自旋等待的效果就会非常好，反之，如果锁被占用的时间很长，那么自旋的线程只会白白消耗处理资源，反而带来性能上的浪费。因此，自旋等待的时间必须要有一定的限度，如果超过了限定次数仍然没有成功获得锁，就应当使用传统的方式去挂起线程了。
    在JDK 1.6中引入了自适应的自旋锁，意味着自旋的时间不在固定了，而是由前一次在同一个锁上的自旋时间及锁在拥有着的状态决定。如果在同一个锁对象上，自旋等待刚刚成功获得过锁，并且持有锁的线程正在运行中，那么虚拟机就会认为这次自旋也很有可能再次成功，进而它将允许自旋等待持续相对更长的时间，比如100个循环。另外，如果对于某个锁，自旋很少成功获得过，那在以后要获取这个锁时将可能省略掉自旋过程，以避免浪费处理器资源。

锁消除

     锁消除是指虚拟机即时编译器在运行时，对一些代码上要求同步，但是被检测到不可能存在共享数据竞争的锁进行消除。消除的主要判定依据来源于逃逸分析的数据支持。如果判断在一段代码中，堆上的所有数据都不会逃逸出去从而被其他线程访问到，那就可以把它们当做栈上数据对待，认为它们是线程私有的，同步加锁自然就无需进行。

锁粗化

    我们在编写代码的时候，总是推荐将同步块的作用范围限制的尽量小——只在共享数据的实际作用域中才进行同步，这样是为了是的需要同步的操作数量尽可能变小，如果存在锁竞争，那等待锁的线程也能尽快拿到锁。
    大部分情况下，上面的原则都是正确的，但是如果一系列的连续操作都对同一个对象反复加锁和解锁，甚至加锁才做是出现子啊循环体中的，那即使没有线程竞争，频繁地进行互斥同步操作也会导致不必要的性能损耗。
    例如连续的append()方法就属于这类情况，如果虚拟机探测到有这样一串零碎的操作都对同一个对象加锁，将会把加锁同步的范围扩展（粗化）到整个操作序列的外部。即可以扩展到第一个append()方法之前直到最后一个append()操作之后，这样只需加锁一次就可以了。

轻量级锁

    传统的使用操作系统互斥量来实现的传统锁称为“重量级”锁，而轻量级锁是相对于重量级锁而言的，它并不是用来代替重量级锁的，它的本意是在没有多线程竞争的前提下，减少传统的重量级锁使用操作系统互斥量产生的性能消耗。
    以HotSpot虚拟机为例，对象头分为两部分：第一部分用于存储对象自身的运行时数据，如哈希码、GC分代年龄等，这部分数据的长度在32位和64位的虚拟机中分别为32bit和64bit，官方称它为“Mark Word”，它是实现轻量级锁和偏向锁的关键。另一部分用于存储指向方法区对象类型数据的指针，如果是数组对象的户啊，它还有一个额外的部分用于存储数组长度。
    对象头信息是与对象自身定义的数据无关的额外存储成本，考虑到虚拟机的空间效率，Mark Word被设计成一个非固定的数据结构以便在技校的空间内存储尽量多的信息，它会根据对象的状态服用自己的存储空间。例如在32位的HotSpot虚拟机中对象未被锁定的状态下，Mark Word的32bit空间中的25bit用于存储对象哈希码，4bit用于存储对象分代年龄，2bit用于存储锁标志位，1bit固定为0。
    在代码进入同步块的时候，如果此同步对象没有被锁定（锁标志位为“01”状态），虚拟机首先将在当前线程的栈帧中建立一个名为锁记录（Lock Record）的空间，用于存储锁对象目前的Mark Word的拷贝。然后，虚拟机将使用CAS操作尝试将对象的Mark Word更新为指向Lock Record的指针。如果这个更新动作成功了，那么这个线程就拥有了该对象的锁，并且对象Mark Word的锁标志位将转变为“00”，即表示此对象处于轻量级锁定状态。
如果这个更新操作失败了，虚拟机首先会检查对象的Mark Word是否指向当前线程的栈帧，如果是，说明当前线程已经拥有了这个对象的锁，那就可以直接进入同步块继续执行，否则说明这个锁对象已经被其他线程枪占了。如果有两条以上的线程争用同一个锁，那轻量级锁就不再有效，要膨胀为重量级锁，锁标志的状态值变为“10”，Mark Word中存储的就是指向重量级锁（互斥量）的指针，后面等待锁的线程也要进入阻塞状态。
    轻量级锁的加锁过程也是通过CAS操作把对象当前的Mark Word和线程中复制的替换回来，如果替换成功，整个同步过程就完成了。如果替换失败，说明有其他线程尝试过获取该锁，那就要在释放锁的同事，唤醒被挂起的线程。
    如果没有竞争，轻量级锁使用CAS操作避免了使用互斥量的开销，但如果存在锁竞争，除了互斥量的开销外，还额外发生了CAS操作，因此在有竞争的情况下，轻量级锁会比传统的重量级锁更慢。

偏向锁

    偏向锁的目的是消除数据在无竞争情况下的同步原语，进一步提高程序的运行性能。如果说轻量级锁是在无竞争的情况下使用CAS操作去消除同步使用的互斥量，那偏向锁就是在无竞争的情况下把整个同步消除掉，连CAS操作都不做了。
    偏向锁会偏向于第一个获得它的线程，如果在接下来的执行过程中，该锁没有被其他的线程获取，则持有偏向锁的线程将永远不需要再进行同步。当锁对象第一次被线程获取的时候，虚拟机将会把对象头中的标志位设为“01”，即偏向模式。同时使用CAS操作把获取到这个锁的线程ID记录在对象的Mark Word之中 ，如果CAS操作成功，持有偏向锁的线程以后每次进入这个锁相关的同步块时，虚拟机都可以不再进行任何同步操作。
    当有另外一个线程去尝试获取这个锁时，偏向模式就宣告结束。根据所对象目前是否处于被锁定的状态，测下哦偏向后恢复到未锁定（标志位为“01”）或轻量级锁定（标志位为“00”）的状态，后续的同步操作就如轻量级锁那样执行。
    偏向锁可以提高带有同步但无竞争的程序性能。它同样是一个带有效益权衡性质的优化，也就是说，它并不一定总是对程序运行有利，如果程序中大多数的锁总是被多个不同线程访问，那偏向锁模式就是多余的。

    <div id="digg" articleid="51420054">
        <dl id="btnDigg" class="digg digg_disable" onclick="btndigga();">
           
             <dt>顶</dt>
            <dd>0</dd>
        </dl>
       
          
        <dl id="btnBury" class="digg digg_disable" onclick="btnburya();">
          
              <dt>踩</dt>
            <dd>0</dd>               
        </dl>
        
    </div>
 <div class="tracking-ad" data-mod="popu_222"><a href="javascript:void(0);">&nbsp;</a>   </div>
<div class="tracking-ad" data-mod="popu_223"> <a href="javascript:void(0);">&nbsp;</a></div>
<script type="text/javascript">
            function btndigga() {
                $(".tracking-ad[data-mod='popu_222'] a").click();
            }
            function btnburya() {
                $(".tracking-ad[data-mod='popu_223'] a").click();
            }
        </script>

• 上一篇虚拟机类加载与运行机制
• 下一篇MyBatis学习

<div style="clear:both; height:10px;"></div>


    <div class="similar_article" style="">
            <h4>我的同类文章</h4>
            <div class="similar_c" style="margin:20px 0px 0px 0px">
                <div class="similar_c_t">
                            <label class="similar_cur">
                                <span style="cursor:pointer" onclick="GetCategoryArticles('6230108','listslim1','foot','51420054');">java虚拟机<em>（5）</em></span>
                            </label>
                </div>
               
                <div class="similar_wrap tracking-ad" data-mod="popu_141" style="max-height:195px;">
                    <a href="http://blog.csdn.net" style="display:none">http://blog.csdn.net</a>
                    <ul class="similar_list fl"><li><em>•</em><a href="http://blog.csdn.net/listslim1/article/details/51567587" id="foot_aritcle_51567587undefined6863313163214857" target="_blank" title="从JVM并发看CPU内存指令重排序">从JVM并发看CPU内存指令重排序</a><span>2016-06-02</span><label><i>阅读</i><b>49</b></label></li> <li><em>•</em><a href="http://blog.csdn.net/listslim1/article/details/51419121" id="foot_aritcle_51419121undefined49239452305381315" target="_blank" title="虚拟机性能监控工具">虚拟机性能监控工具</a><span>2016-05-15</span><label><i>阅读</i><b>111</b></label></li> <li><em>•</em><a href="http://blog.csdn.net/listslim1/article/details/51418146" id="foot_aritcle_51418146undefined30195460357853854" target="_blank" title="java内存区域与内存溢出异常">java内存区域与内存溢出异常</a><span>2016-05-15</span><label><i>阅读</i><b>1329</b></label></li> </ul>

                    <ul class="similar_list fr"><li><em>•</em><a href="http://blog.csdn.net/listslim1/article/details/51419862" id="foot_aritcle_51419862undefined2988563171300449" target="_blank" title="虚拟机类加载与运行机制">虚拟机类加载与运行机制</a><span>2016-05-15</span><label><i>阅读</i><b>134</b></label></li> <li><em>•</em><a href="http://blog.csdn.net/listslim1/article/details/51419007" id="foot_aritcle_51419007undefined6819575095515691" target="_blank" title="java垃圾收集器">java垃圾收集器</a><span>2016-05-15</span><label><i>阅读</i><b>966</b></label></li> </ul>
                </div>
            </div>
        </div>    
<script type="text/javascript">
    $(function () {
        GetCategoryArticles('6230108', 'listslim1','foot','51420054');
    });
</script>