Java 锁机制性能初探

逃离我推掉我的手 2023-01-04 14:49 106阅读 0赞

### 粗探秘锁性能 ###

*  前言
 *   *  结果
     *  测试代码

# 前言 #

<table> 
 <thead> 
  <tr> 
   <th>环境</th> 
   <th>备注</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>JDK</td> 
   <td>版本 11</td> 
  </tr> 
  <tr> 
   <td>OS</td> 
   <td>Win10</td> 
  </tr> 
  <tr> 
   <td>CPU</td> 
   <td>AMD R7 4800U</td> 
  </tr> 
  <tr> 
   <td>内存</td> 
   <td>16G</td> 
  </tr> 
  <tr> 
   <td>磁盘</td> 
   <td>SAMSUNG MZVLB512HBJQ-000L 2</td> 
  </tr> 
 </tbody> 
</table>

`main方法测试，非专业测试方式，存在一定的误差，但也具有一定的参考价值`

**测试的锁类型**

<table> 
 <thead> 
  <tr> 
   <th>锁方式</th> 
   <th>对应方法</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>synchronized 方法锁</td> 
   <td>syncByMethod</td> 
  </tr> 
  <tr> 
   <td>synchronized 常量锁</td> 
   <td>syncByConstant</td> 
  </tr> 
  <tr> 
   <td>synchronized 对象锁</td> 
   <td>syncByObj</td> 
  </tr> 
  <tr> 
   <td>StampedLock 写锁</td> 
   <td>stampedLock</td> 
  </tr> 
  <tr> 
   <td>ReentrantLock</td> 
   <td>reentrantLock</td> 
  </tr> 
 </tbody> 
</table>

## 结果 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N1b2xvbmdkc2U_size_16_color_FFFFFF_t_70_pic_center]

## 测试代码 ##

package org.example.thread;
    
    import cn.hutool.core.collection.CollUtil;
    import cn.hutool.core.date.DateUtil;
    import cn.hutool.core.date.TimeInterval;
    import com.google.common.collect.Lists;
    import lombok.SneakyThrows;
    
    import java.util.ArrayList;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    import java.util.concurrent.locks.StampedLock;
    import java.util.stream.Collectors;
    
    /** * @author utrix * @date 2021/1/10 */
    public class LockDemo { 
    
        private static long count = 0;
        public static final String LOCK_KEY = LockDemo.class.getSimpleName();
        public static final int RUN_NUMBER = 100;
        // public static final int RUN_NUMBER = 100*100;
        public static final int TEST_NUMBER = 20 * 100;
        public static final ArrayList<Long> TIME_COUNT = Lists.newArrayListWithCapacity(TEST_NUMBER);
    
        /* 总结：synchronized经过不断的优化，到目前JDK8版本已经不再是低级笨重的锁了，在一起其他场合性能已经优于reentrantLoack和stampedLock了 原因：synchronized引入了偏向锁、轻量级锁、重量级锁，并提供了自动的升级降级机制 */
    
        @SneakyThrows
        public static void main(String[] args) { 
            LockDemo lockDemo = new LockDemo();
            lockDemo.avgCount("syncByConstant",lockDemo::syncByConstant);
            // lockDemo.avgCount("syncByObj",lockDemo::syncByObj);
            // lockDemo.avgCount("reentrantLock",lockDemo::reentrantLock);
            // lockDemo.avgCount("stampedLock",lockDemo::stampedLock);
            // lockDemo.avgCount("syncByMethod",lockDemo::syncByMethod);
        }
    
        private void avgCount(String type, Runnable run) { 
            for (int i = 0; i < TEST_NUMBER; i++) { 
                runByDefine(type, run);
            }
            Double avg = TIME_COUNT.stream().collect(Collectors.averagingLong(Long::longValue));
            System.err.printf("%s 方式用时最长 %d 毫秒, 最短 %d 毫秒, 平均 %f 毫秒 \n", type, CollUtil.max(TIME_COUNT),
                    CollUtil.min(TIME_COUNT), avg);
        }
    
        private void runByDefine(String type, Runnable run) { 
            TimeInterval timer = DateUtil.timer();
            for (int i = 0; i < RUN_NUMBER; i++) { 
                Thread thread = new Thread() { 
                    @Override
                    public void run() { 
                        run.run();
                    }
                };
                thread.start();
            }
            long time = timer.intervalMs();
            TIME_COUNT.add(time);
            System.out.printf("%s 方式执行用时 %d 毫秒 \n", type, time);
        }
    
        /** * synchronized 方法锁 * 方法锁锁定的该方法所属对象隐藏字段的monitor */
        private synchronized void syncByMethod() { 
            count++;
        }
    
        /** * synchronized 对象锁 */
        private void syncByObj() { 
            synchronized (this) { 
                count++;
            }
        }
    
        /** * synchronized 常量锁 */
        private void syncByConstant() { 
            synchronized (LOCK_KEY) { 
                count++;
            }
        }
    
        /** * JDK8 StampedLock锁 */
        private void stampedLock() { 
            StampedLock lock = new StampedLock();
            Lock writeLock = lock.asWriteLock();
            try { 
                writeLock.lock();
                count++;
            } finally { 
                writeLock.unlock();
            }
        }
    
        /** * ReentrantLock 锁 */
        private void reentrantLock() { 
            ReentrantLock reentrantLock = new ReentrantLock();
            try { 
                reentrantLock.lock();
                count++;
            } finally { 
                reentrantLock.unlock();
            }
        }
    
    }

**(本文完！如需转载请付本文链接！)**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N1b2xvbmdkc2U_size_16_color_FFFFFF_t_70_pic_center]: /images/20221119/3016b2f146e6449b8ce3ea513334f927.png