深入JVM内核7 锁

深入JVM内核 目录

1. 线程安全

• 多线程网站统计访问人数
  使用锁，维护计数器的串行访问与安全性
• 多线程访问ArrayList

public class ArrayListTest {    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) throws InterruptedException {        Thread t1=new Thread(new AddToList(0));        Thread t2=new Thread(new AddToList(1));        t1.start();        t2.start();        while(t1.isAlive() || t2.isAlive()){            Thread.sleep(1);        }        System.out.println(numberList.size());    }}

输出

1000009Exception in thread "Thread-0" java.lang.ArrayIndexOutOfBoundsException: 10    at java.util.ArrayList.add(ArrayList.java:463)    at ArrayListTest$AddToList.run(ArrayListTest.java:17)    at java.lang.Thread.run(Thread.java:748)

2. 对象头Mark

Mark Word，对象头的标记，32位
形容对象的hash、锁信息，垃圾回收标记，年龄

• 指向锁记录的指针
• 指向monitor的指针
• GC标记
• 偏向锁线程ID

3. 锁类型

3.1 偏向锁

• 大部分情况是没有竞争的，所以可以通过偏向来提高性能
• 所谓的偏向，就是偏心，即锁会偏向于当前已经占有锁的线程
• 将对象头Mark的标记设置为偏向，并将线程ID写入对象头Mark
• 只需没有竞争，取得偏向锁的线程，在将来进入同步块，不需要做同步
• 当其余线程请求相同的锁时，偏向模式结束
• -XX:+UseBiasedLocking
  默认启用
• 在竞争激烈的场合，偏向锁会添加系统负担

3.2 轻量级锁

BasicObjectLock

嵌入在线程栈中的对象

• 普通的锁解决性能不够理想，轻量级锁是一种快速的锁定方法。
• 假如对象没有被锁定
  将对象头的Mark指针保存到锁对象中
  将对象头设置为指向锁的指针（在线程栈空间中）

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

lock位于线程栈中
轻量级锁
假如轻量级锁失败，表示存在竞争，更新为重量级锁（常规锁）
在没有锁竞争的前提下，减少传统锁使用OS互斥量产生的性能损耗
在竞争激烈时，轻量级锁会多做很多额外操作，导致性能下降

3.3 自旋锁

当竞争存在时，假如线程可以很快取得锁，那么可以不在OS层挂起线程，让线程做几个空操作（自旋）
JDK1.6中-XX:+UseSpinning开启
JDK1.7中，去掉此参数，改为内置实现
假如同步块很长，自旋失败，会降低系统性能
假如同步块很短，自旋成功，节省线程挂起切换时间，提升系统性能

偏向锁，轻量级锁，自旋锁总结

• 不是Java语言层面的锁优化方法
• 内置于JVM中的获取锁的优化方法和获取锁的步骤
  偏向锁可用会先尝试偏向锁
  轻量级锁可用会先尝试轻量级锁
  以上都失败，尝试自旋锁
  再失败，尝试普通锁，使用OS互斥量在操作系统层挂起

4. 锁优化

4.1 减少锁持有时间

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

优化后：

public void syncMethod2(){    othercode1();    synchronized(this){        mutextMethod();    }    othercode2();}

4.2 减小锁粒度

• 将大对象，拆成小对象，大大添加并行度，降低锁竞争

• 偏向锁，轻量级锁成功率提高

• ConcurrentHashMap

1. 若干个Segment ：Segment<K,V>[] segments
2. Segment中维护HashEntry<K,V>
3. 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);}}

4.3 锁分离

根据功能进行锁分离
ReadWriteLock
读多写少的情况，可以提高性能

读写分离思想可以延伸，只需操作互不影响，锁即可以分离
LinkedBlockingQueue
队列
链表

4.4 锁粗化

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

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

优化后：

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

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

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

4.5 锁消除

public static void main(String args[]) throws InterruptedException {    long start = System.currentTimeMillis();    for (int i = 0; i < CIRCLE; 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();}

5 无锁

• 锁是悲观的操作
• 无锁是乐观的操作
• 无锁的一种实现方式
  CAS(Compare And Swap)
  非阻塞的同步
  CAS(V,E,N)
• 在应用层面判断多线程的干扰，假如有干扰，则通知线程重试
  java.util.concurrent.atomic.AtomicInteger

public final int getAndSet(int newValue) {    for (;;) {        int current = get();        if (compareAndSet(current, newValue))            return current;    }}

java.util.concurrent.atomic包使用无锁实现，性能高于一般的有锁操作

特别感谢

深入JVM内核—原理、诊断与优化