synchronized的锁优化

synchronized的锁优化

选择共享锁的对象的粒度大小

理由： 就像hashMap的一样， hashMap本来不是线程安全的， 如果我们要使得他的方法是线程安全的，就得让他为共享变量串行，自然而然我们就是使用装饰者模式，
例如：

Map<Object, Object> synchronizedMap = Collections.synchronizedMap(new HashMap<>());

private static class SynchronizedMap<K,V>
        implements Map<K,V>, Serializable {
        private static final long serialVersionUID = 1978198479659022715L;

        private final Map<K,V> m;     // Backing Map
        final Object      mutex;        // Object on which to synchronize

        SynchronizedMap(Map<K,V> m) {
            this.m = Objects.requireNonNull(m);
            mutex = this;
        }

        SynchronizedMap(Map<K,V> m, Object mutex) {
            this.m = m;
            this.mutex = mutex;
        }

        public int size() {
            synchronized (mutex) {return m.size();}
        }
        public boolean isEmpty() {
            synchronized (mutex) {return m.isEmpty();}
        }
        public boolean containsKey(Object key) {
            synchronized (mutex) {return m.containsKey(key);}
        }
        public boolean containsValue(Object value) {
            synchronized (mutex) {return m.containsValue(value);}
        }
        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);}
        }
        public V remove(Object key) {
            synchronized (mutex) {return m.remove(key);}
        }
        public void putAll(Map<? extends K, ? extends V> map) {
            synchronized (mutex) {m.putAll(map);}
        }
        public void clear() {
            synchronized (mutex) {m.clear();}
        }

       .............

应该是装饰者模式滴。

但是这样做虽然简单了，但是根据 hashmap的特性来说，锁的粒度太大了，锁的粒度是整个互斥变量，也就等价于整个HashMap， 所以CurrentHahsMap才是最牛i， 所以锁粒度的选择，要深入理解业务，找出最小的锁粒度

逃逸分析+标量替换

这篇不是讲的锁优化的问题吗，怎么跑到逃逸了。 慢慢道来，应为要懂jvm对synchronized的锁消除需要有这些前置知识。

什么是内存逃逸？ 我们都知道 new 的对象呃是在堆里面的， 但是堆里面的对象太多了就会引起full gc， 所以jvm就是优化如果一个对象在一个方法内被new出来，但是 这个对象经过jvm分析，只有方法内被用到，他的引用没有跑出方法外面，那么jvm就会把这个对象放到 方法栈上。
实际上就是看局部变量有么有逃出方法之外

-server                             //jit的c2编译器

-XX:+DoEscapeAnalysis  //逃逸分析

-XX:+EliminateLocks       //锁消除

-XX:+EliminateAllocations  //标量替换

虚拟机参数，默认是开启需要把它去掉。

标量替换：就是说把对象打散之后分配在栈或者寄存器上

public class TaoyiAnalysiz {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 2000000; i++) {
            method();
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
    
    public static void method(){
        byte[] bytes = new byte[2];
        bytes[0] = 1;
    }
}

默认情况：开启逃逸分析标量替换的优化： 执行实际 8毫秒

禁用标量替换： 执行的实际24毫秒

再来继续设置:
-server
-XX:+DoEscapeAnalysis
-XX:+EliminateLocks
-XX:-EliminateAllocations
-Xmx50m
-Xms50m
-XX:+PrintGC

结果：
[0.004s][warning][gc] -XX:+PrintGC is deprecated. Will use -Xlog:gc instead.
[0.010s][info ][gc] Using G1
[0.169s][info ][gc] GC(0) Pause Young (Normal) (G1 Evacuation Pause) 23M->0M(50M) 1.915ms
24

开始标量替换：
-server
-XX:+DoEscapeAnalysis
-XX:+EliminateLocks
-XX:+EliminateAllocations
-Xmx50m
-Xms50m
-XX:+PrintGC

结果：

[0.003s][warning][gc] -XX:+PrintGC is deprecated. Will use -Xlog:gc instead.
[0.010s][info ][gc] Using G1
8

结果一对比：标量替换，导致对象不会再堆分配，一定程度上减少了GC

锁消除

如果方法里面的没有发生逃逸，那么都是局部变量，所以jvm会把锁消除

public class TaoyiAnalysiz {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 2000000; i++) {
            caculate();
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }

    public synchronized static void caculate() {
        int x = 0;
        for (int i = 0; i < 10; i++) {
            x++;
        }
    }
}

执行时间：16

-server
-XX:-DoEscapeAnalysis
-XX:-EliminateLocks
-XX:-EliminateAllocations

执行时间 40