3.深入jvm内核-原理、诊断与优化-8. 锁

一、锁

1. 线程安全

    ```
    多线程网站统计访问人数
    使用锁，维护计数器的串行访问与安全性
    多线程访问ArrayList
    ```
    ```
    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());
    }
    ```
    ```
    Exception in thread "Thread-0" java.lang.ArrayIndexOutOfBoundsException: 24552
    	at java.util.ArrayList.add(ArrayList.java:463)
    	at LockRunnable$AddToList.run(JvmLockCompare.java:101)
    	at java.lang.Thread.run(Thread.java:748)
    1010143
    ```
   

   

2. 对象头Mark

    Mark Word，对象头的标记，32位
    描述对象的hash、锁信息，垃圾回收标记，年龄
    指向锁记录的指针
    指向monitor的指针
    GC标记
    偏向锁线程ID
   

3. 偏向锁

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

   本例中，使用偏向锁，可以获得5%以上的性能提升

   -XX:+UseBiasedLocking -XX:BiasedLockingStartupDelay=0

   -XX:-UseBiasedLocking

   
   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);
   }
   

4. 轻量级锁

   

   

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

5. 自旋锁

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

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

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

7. 减少锁持有时间

   

8. 减小锁粒度

   

    ConcurrentHashMap	
    若干个Segment ：Segment<K,V>[] segments
    Segment中维护HashEntry<K,V>
    put操作时
    先定位到Segment，锁定一个Segment，执行put
    在减小锁粒度后， ConcurrentHashMap允许若干个线程同时进入
   

9. 锁分离

   

   

10. 锁粗化

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

    示例1

    

    示例2

    

11. 锁消除

     在即时编译器时，如果发现不可能被共享的对象，则可以消除这些对象的锁操作
    

    	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();
    	}
    
    

    CIRCLE=20000000

     -server -XX:+DoEscapeAnalysis -XX:+EliminateLocks
    

    craeteStringBuffer: 1057 ms

     -server -XX:+DoEscapeAnalysis -XX:-EliminateLocks
    

    craeteStringBuffer: 1857 ms

12. 无锁

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

    示例

    

来源：https://my.oschina.net/u/3730149/blog/3112158