高并发怎么减少锁的竞争

秒速五厘米 2024-04-03 09:43 129阅读 0赞

#### 目录 ####

*  1.减少锁的持有时间
 *  2.减少锁粒度
 *  3.锁分离
 *  4.锁消除
 *  5.锁粗化

## 1.减少锁的持有时间 ##

案例代码：

public synchronized void syncMethod() {
        
        otherCode1();
        mutextMethod(); // 真正需要同步的代码
        otherCode2();
    }

案例代码中进入syncMethod方法的线程有且只有一个，其他线程都会阻塞，但是细心可以发现，syncMethod方法中的只有mutextMethod的代码需要同步，而otherCode1、otherCode2无需同步，因此可以考虑只将mutextMethod代码放到同步区间中，从而提高锁的性能。如下：

public void syncMethod() {
        
        otherCode1();
        Synchronization(this) {
        
            mutextMethod(); // 真正需要同步的代码
        }
        otherCode2();
    }

使得线程可以同时进入syncMethod方法的otherCode1、otherCode2代码，而仅仅只需在mutextMethod代码中做同步处理，以减少锁的时间、锁的范围、锁冲突的可能性，提高锁的性能。

## 2.减少锁粒度 ##

> 将大对象，拆成小对象，大大增加并行度，降低锁竞争。SynchronizedHashMap和ConcurrentHashMap就是一个典型的代表。

HashMap不是线程安全的，因此在多线程场景下，需要将HashMap转换成线程安全的，因此可以简单的使用Collections的SynchronizedMap接口获取一个同步的HashMap，不足的是这个同步HashMap非常的重，当线程访问、修改数据都要获得锁，如下：

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。

传统锁下，读写共用一把锁，而ReadWriteLock将读锁和写锁相分离，在没有写的场景下，读读是不阻塞，无等待的，最高级别的并发，而在涉及写的时候，读和写都需要申请锁，因此写的过程中，可能会读到旧数据，导致数据不一致。  
**读写锁的情况如下：**

ReadWriteLock在读多写少的情况下，可以提高性能。  
读写分离思想可以延伸出：主要操作互不影响，锁就可以分离，譬如：LinkedBlockIngQueue，是一个通过链表实现的阻塞队列。数据结构如下：  
![在这里插入图片描述][0181c4267403485bbc609231241b0964.png]  
队列的特点规定，读只能在队头读，而写之后再队尾写，因此可以分别使用两把锁来对读取进行同步控制，从而提高结构的并行度。

## 4.锁消除 ##

从JIT角度看相当于无视它，synchronized (o)不存在了,这个锁对象并没有被共用扩散到其它线程使用，  
**因为要循环new o对象10次，人人都有锁，不需要抢了**

**
     * 锁消除
     * 从JIT角度看相当于无视它，synchronized (o)不存在了,这个锁对象并没有被共用扩散到其它线程使用，
     * 极端的说就是根本没有加这个锁对象的底层机器码，消除了锁的使用
     */
    public class LockClearUPDemo {
        
        static Object objectLock = new Object();//正常的
    
        public void m1() {
        
            //锁消除,JIT会无视它，synchronized(对象锁)不存在了。不正常的
            Object o = new Object();
    
            synchronized (o) {
        
                System.out.println("-----hello LockClearUPDemo" + "\t" + o.hashCode() + "\t" + objectLock.hashCode());
            }
        }
    
        public static void main(String[] args) {
        
            LockClearUPDemo demo = new LockClearUPDemo();
    
            for (int i = 1; i <= 10; i++) {
        
                new Thread(() -> {
        
                    demo.m1();
                }, String.valueOf(i)).start();
            }
        }
    }

正确写法(写在外面)

public class LockClearUPDemo {
        
        static Object objectLock = new Object();//正常的
    
        public void m1() {
        
            synchronized (objectLock){
        
                System.out.println("-----hello LockClearUPDemo" + "\t" + objectLock.hashCode() + "\t" + objectLock.hashCode());
            }
        }
    
        public static void main(String[] args) {
        
            LockClearUPDemo demo = new LockClearUPDemo();
    
            for (int i = 1; i <= 10; i++) {
        
                new Thread(() -> {
        
                    demo.m1();
                }, String.valueOf(i)).start();
            }
        }
    }

## 5.锁粗化 ##

假如方法中首尾相接，前后相邻的都是同一个锁对象，那JIT编译器就会把这几个synchronized块合并成一个大块，加粗加大范围，一次申请锁使用即可，避免次次的申请和释放锁，提升了性能

/**
     * 锁粗化
     * 假如方法中首尾相接，前后相邻的都是同一个锁对象，那JIT编译器就会把这几个synchronized块合并成一个大块，
     * 加粗加大范围，一次申请锁使用即可，避免次次的申请和释放锁，提升了性能
     */
    public class LockBigDemo {
        
    
        static Object objectLock = new Object();
    
        public static void main(String[] args) {
        
            new Thread(() -> {
        
                synchronized (objectLock) {
        
                    System.out.println("11111");
                }
                synchronized (objectLock) {
        
                    System.out.println("22222");
                }
                synchronized (objectLock) {
        
                    System.out.println("33333");
                }
                synchronized (objectLock) {
        
                    System.out.println("11111");
                    System.out.println("22222");
                    System.out.println("33333");
                }
            }, "a").start();
    
    
        }
    
    }

**典型案例：**

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

可以将锁申请提升到for循环外，以减少不必要的锁申请次数：

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

[0181c4267403485bbc609231241b0964.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/88a5ace93c46441bb5c6916481e9149b.png