深入JVM内核(八)

JAVA 2015-12-13

相信学过Java的同学都或多或少了解过这个概念,下面我们一起来看看JVM中的锁是怎么样的。 (请注意传统的锁是重量级的,monitorenter有可能让线程在OS层面挂起) 锁有什么用呢? 锁可以用来维护java程序中的线程安全。比如多线程网站统计访问人数,我们可以使用锁,维护计数器的串行访问与安全性。

请看一个示例程序:

import java.util.ArrayList;
import java.util.List;

public class Lock {

    public static List<Integer> numberList =new ArrayList<Integer>();
    public static class AddToList implements Runnable{
        int startnum=0;
        public AddToList(int startnumber){
            startnum=startnumber;
        }
        @Override
        public void run() {
            int count=0;
            while(count<1000000){
                numberList.add(startnum);
                startnum+=2;
                count++;
            }
        }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Thread t1=new Thread(new AddToList(0));
        Thread t2=new Thread(new AddToList(1));
        t1.start();
        t2.start();
        while(t1.isAlive() || t2.isAlive()){
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        System.out.println(numberList.size());
    }

}

运行后结果是:1.png

该程序是非线程安全的,抛出异常。

在了解锁之前我们要了解对象头Mark,它存在于JVM中,其中Mark Word被称为对象头的标记,32位;对象头负责描述对象的hash、锁信息,垃圾回收标记,年龄(指向锁记录的指针,指向monitor的指针,GC标记,偏向锁线程ID)

1.偏向锁是锁中的一种,偏向锁大部分情况是没有竞争的,所以可以通过偏向来提高性能,所谓的偏向,就是偏心,即锁会偏向于当前已经占有锁的线程,偏向锁将对象头Mark的标记设置为偏向,并将线程ID写入对象头Mark,也就是说只要没有竞争,获得偏向锁的线程,在将来进入同步块,不需要做同步。当其他线程请求相同的锁时,偏向模式结束。可以通过参数-XX:+UseBiasedLocking来开启(默认开启),要注意的是在竞争激烈的合,偏向锁会增加系统负担。 下面来看一个例子:

import java.util.List;
import java.util.Vector;

public class Lock {
    public static List<Integer> numberList =new Vector<Integer>();
    public static void main(String[] args) throws InterruptedException {
        long begin=System.currentTimeMillis();
        int count=0;
        int startnum=0;
        while(count<10000000){
            numberList.add(startnum);
            startnum+=2;
            count++;
        }
        long end=System.currentTimeMillis();
        System.out.println(end-begin);
    }
}

运行时使用参数-XX:+UseBiasedLocking -XX:BiasedLockingStartupDelay=0

输出:3522

2.还有一种叫做轻量级锁,如下图BasicObjectLock是嵌入在线程栈中的对象

2.png

而普通的锁处理性能不够理想,轻量级锁是一种快速的锁定方法. 如果对象没有被锁定,可以将对象头的Mark指针保存到锁对象中,或将对象头设置为指向锁的指针(在线程栈空间中)。注意要判断一个线程是否持有轻量级锁,只要判断对象头的指针,是否在线程的栈空间范围内。

lock->set_displaced_header(mark);
 if (mark == (markOop) Atomic::cmpxchg_ptr(lock, obj()->mark_addr(), mark)) {
      TEVENT (slow_enter: release stacklock) ;
      return ;
}

如果轻量级锁失败,表示存在竞争,升级为重量级锁(常规锁),在没有锁竞争的前提下,减少传统锁使用OS互斥量产生的性能损耗,但是在竞争激烈时,轻量级锁会多做很多额外操作,导致性能下降。

3.自旋锁:当竞争存在时,如果线程可以很快获得锁,那么可以不在OS层挂起线程,让线程做几个空操作(自旋),自旋锁在jdk7之后内置实现。要注意如果同步块很长,自旋失败,会降低系统性能;如果同步块很短,自旋成功,节省线程挂起切换时间,提升系统性能。

总结:以上三种锁不是Java语言层面的锁优化方法,是JVM层面的。 其中获取锁的优化方法和获取锁的步骤如下:

  1. 偏向锁可用会先尝试偏向锁
  2. 轻量级锁可用会先尝试轻量级锁
  3. 以上都失败,尝试自旋锁
  4. 再失败,尝试普通锁,使用OS互斥量在操作系统层挂起

要优化锁的使用,应该做到: 1.减少锁持有时间 例如:

public synchronized void syncMethod(){
    othercode1();
    mutextMethod();
    othercode2();
}

可以优化为

public void syncMethod2(){
    othercode1();
    synchronized(this){
        mutextMethod();
    }
    othercode2();
}
注意:持有时间长,自旋容易失败

2.减小锁粒度 由于粒度大,竞争激烈,偏向锁,轻量级锁失败概率会变高,所以应该尽量减小粒度。 减小粒度也就是将大对象,拆成小对象,大大增加并行度,降低锁竞争;并提高偏向锁,轻量级锁成功率。注意ConcurrentHashMap以及HashMap的同步实现。 具体说说ConcurrentHashMap,它有若干个Segment :Segment<K,V>[] segments;Segment中维护HashEntry<K,V>(hashmap中维护了Entry<K,V>的数组);当put操作时,先定位到Segment,锁定一个Segment,执行put。注意在减小锁粒度后, ConcurrentHashMap允许若干个线程同时进入。 HashMap的同步如何实现呢?可以用Collections.synchronizedMap(Map<K,V> m),它返回SynchronizedMap对象

 public V get(Object key) {
            synchronized (mutex) {return m.get(key);}
        }
public V put(K key, V value) {
            synchronized (mutex) {return m.put(key, value);}
}

3.锁分离

可以根据功能进行锁分离,注意ReadWriteLock方法(对文件读取时,允许多个线程同时进入),注意在读多写少的情况,可以提高性能。

3.png

读写分离思想可以延伸,只要操作互不影响,锁就可以分离,注意LinkedBlockingQueue的实现,它可以使用takeLock和putLock两个锁。

4.锁粗化 通常情况下,为了保证多线程间的有效并发,会要求每个线程持有锁的时间尽量短,即在使用完公共资源后,应该立即释放锁。只有这样,等待在这个锁上的其他线程才能尽早的获得资源执行任务。但是,凡事都有一个度,如果对同一个锁不停的进行请求、同步和释放,其本身也会消耗系统宝贵的资源,反而不利于性能的优化 看两个优化的例子

示例1

 public void demoMethod(){
    synchronized(lock){
        //do sth.
    }
    //做其他不需要的同步的工作,但能很快执行完毕
    synchronized(lock){
        //do sth.
    }
}

优化后

public void demoMethod(){
        //整合成一次锁请求
    synchronized(lock){
        //do sth.
        //做其他不需要的同步的工作,但能很快执行完毕
    }
}

示例2

for(int i=0;i<CIRCLE;i++){
    synchronized(lock){

    }
}

优化后

synchronized(lock){
for(int i=0;i<CIRCLE;i++){

    }
}

5.锁消除 在即时编译器时,如果发现不可能被共享的对象,则可以消除这些对象的锁操作 有时锁不是由程序员引入的,JDK自带的一些库,可能内置锁,对于栈上对象,不会被全局访问的,没有必要加锁。

 public static void main(String args[]) throws InterruptedException {
    long start = System.currentTimeMillis();
    for (int i = 0; i < 2000000; i++) {
        craeteStringBuffer("JVM", "Diagnosis");
    }
    long bufferCost = System.currentTimeMillis() - start;
    System.out.println("craeteStringBuffer: " + bufferCost + " ms");
}

public static String craeteStringBuffer(String s1, String s2) {
    StringBuffer sb = new StringBuffer();
    sb.append(s1);
    sb.append(s2);
    return sb.toString();
}

对于以上程序,使用参数-server -XX:+DoEscapeAnalysis -XX:+EliminateLocks,输出时间108ms;如果使用-server -XX:+DoEscapeAnalysis -XX:-EliminateLocks,输出时间234ms !由此可见锁的优化效果。

6.无锁 锁是悲观的操作,它保证了线程安全,但是带来消耗,而无锁是乐观的操作。 无锁的一种实现方式 CAS(Compare And Swap)

实现无锁要在应用层面判断多线程的干扰,如果有干扰,则通知线程重试。

补充:CAS算法的过程是这样:它包含3个参数CAS(V,E,N)。V表示要更新的变量,E表示预期值,N表示新值。仅当V值等于E值时,才会将V的值设为N,如果V值和E值不同,则说明已经有其他线程做了更新,则当前线程什么都不做。最后,CAS返回当前V的真实值。CAS操作是抱着乐观的态度进行的,它总是认为自己可以成功完成操作。当多个线程同时使用CAS操作一个变量时,只有一个会胜出,并成功更新,其余均会失败。失败的线程不会被挂起,仅是被告知失败,并且允许再次尝试,当然也允许失败的线程放弃操作。基于这样的原理,CAS操作即时没有锁,也可以发现其他线程对当前线程的干扰,并进行恰当的处理。

看一个例子: 用到的类:java.util.concurrent.atomic.AtomicInteger(java.util.concurrent.atomic包使用无锁实现,性能高于一般的有锁操作)

     public final int getAndSet(int newValue) {  //设置新值,返回旧值

        for (;;) {
           int current = get();    
            if (compareAndSet(current, newValue))  
                return current;
 //public final boolean compareAndSet(int expect, int update) 更新成功返回true 
        }
    }

本文由 Tony 创作,采用 知识共享署名 3.0,可自由转载、引用,但需署名作者且注明文章出处。

赏个馒头吧