使用ZooKeeper实现Java跨JVM的分布式锁(优化构思)

时间  2019-12-07
标签 使用 zookeeper 实现 java jvm 分布式 优化 构思 栏目 Zookeeper 繁體版
原文   原文链接

1、使用ZooKeeper实现Java跨JVM的分布式锁java

2、使用ZooKeeper实现Java跨JVM的分布式锁(优化构思)node

3、使用ZooKeeper实现Java跨JVM的分布式锁(读写锁)redis

 

说明：这篇文章是基于 使用ZooKeeper实现Java跨JVM的分布式锁 的，没有阅读的朋友请先阅读前面的文章后在阅读本文。apache

上一篇文章中介绍了如何使用分布式锁，而且对原来的公平锁进行了扩展，实现了非公平锁，已经可以知足大部分跨进程（JVM）锁的需求了。缓存

 

问题：咱们都知道在单个JVM内部实现锁的机制很方便，Java也提供了很丰富的API能够实现，例如Synchronized关键字， ReentrantLock等等，可是在集群环境中，都是多个JVM协同工做，当须要一些全局锁时就要用到上面介绍的分布式锁了，可是这种锁的缺点在于每次客户端（这里说的客户端能够理解为不一样JVM当中的线程）须要获取锁时都须要与zook服务端交互，建立znode，等待着本身获取锁，这种网络通讯无疑会给服务器带来必定的压力，那么咱们有没有什么办法来减小这种压力呢？服务器

 

场景：有一种很常见的场景就是更新缓存，那么咱们通常的处理逻辑以下。网络

一、 首选根据key获取资源，若是资源存在，用之。并发

二、若是不存在，则申请获取锁（使用共享锁)。jvm

三、获取到锁之后，再次判断资源是否存在（防止重复更新），若是存在说明已经有人更新了，方法退出，不然更新缓存。分布式

四、释放锁。

假设如今有10（1-10）个线程同时执行上诉逻辑，若是资源不存在，那么它们所有会执行第（2）步获取锁，在同一时刻，只会有1个线程获取锁，其它9个线程阻塞，等待获取锁。如今咱们假设线程1获取到锁，开始执行（3-4）步动做，在第（3步）当中，再次判断资源是否存在，（确定不存在由于它是第一个进去的），因此它负责加载资源放入缓存，而后释放锁， 再说其它线程（2-10）它们依次获取到锁，而后执行（3，4）动做，再次判断资源是否存在（已经存在了，由于1号线程已经放进去了），因此他们直接退出，释放锁。因而可知只有1号线程获取锁是有意义的，可是它们都须要与zook进行网络通信，所以会给网络带来压力。

 

若是说咱们有A,B 二台服务器进行集群，这10个线程获取锁的请求分别来自这2台服务器，例如（1-5）号线程来自A服务器， （6-10）号线程来自B服务器，那么它们与zk交互了10次，建立10个znode来申请锁，可是若是咱们进行必定的优化，它们只要与zk交互2次就够了，咱们来把上面的逻辑改造一下。

 

一、 首选根据key获取资源，若是资源存在，用之。

二、若是不存在，则申请获取锁（JVM进程内的锁)。

三、获取到锁(JVM进程内的锁)，再次判断资源是否存在，若是资源存在就退出，没啥好所的。

四、若是资源不存在，则申请获取锁(分布式锁)。

五、获取到锁（分布式锁）再次判断资源是否存在（防止重复更新），若是存在说明已经有人更新了，方法退出，不然更新缓存。

六、释放分布式锁，释放JVM进程内的锁。

 

代码：我把实现逻辑都放在一块儿了，方便给你们演示，若是有逻辑错误欢迎你们留言指正。

 

[java]  view plain  copy
 
 在CODE上查看代码片派生到个人代码片
  1. package com.framework.code.demo.zook;  
  2.   
  3. import java.util.HashMap;  
  4. import java.util.Map;  
  5. import java.util.concurrent.ExecutorService;  
  6. import java.util.concurrent.Executors;  
  7. import java.util.concurrent.TimeUnit;  
  8. import java.util.concurrent.locks.ReentrantLock;  
  9.   
  10. import org.apache.curator.framework.CuratorFramework;  
  11. import org.apache.curator.framework.CuratorFrameworkFactory;  
  12. import org.apache.curator.framework.recipes.locks.InterProcessMutex;  
  13. import org.apache.curator.retry.ExponentialBackoffRetry;  
  14.   
  15. import com.framework.code.demo.zook.lock.NoFairLockDriver;  
  16.   
  17. public class Main {  
  18.       
  19.     //咱们用一个static的map模拟一个第三方独立缓存  
  20.     public static Map<String, Object> redis = new HashMap<String, Object>();  
  21.     public static final String key = "redisKey";  
  22.       
  23.     public static void main(String[] args) throws InterruptedException {  
  24.         //建立俩个对象分别模拟2个进程  
  25.         RedisProcess processA = new RedisProcess();  
  26.         RedisProcess processB = new RedisProcess();  
  27.           
  28.         //每一个进程别分用50个线程并发请求  
  29.         ExecutorService service = Executors.newFixedThreadPool(100);  
  30.         for (int i = 0; i < 50; i++) {  
  31.             service.execute(processA);  
  32.             service.execute(processB);  
  33.         }  
  34.           
  35.         service.shutdown();  
  36.         service.awaitTermination(30, TimeUnit.SECONDS);  
  37.     }  
  38.       
  39.     public static class RedisProcess implements Runnable {  
  40.         CuratorFramework client;  
  41.         //ZK分布式锁  
  42.         InterProcessMutex distributedLock;  
  43.         //JVM内部锁  
  44.         ReentrantLock jvmLock;  
  45.           
  46.         public RedisProcess() {  
  47.             client = CuratorFrameworkFactory.newClient("192.168.1.18:2181",   
  48.                     new ExponentialBackoffRetry(1000,3));  
  49.             client.start();  
  50.             distributedLock = new InterProcessMutex(client,"/mylock", new NoFairLockDriver());  
  51.             jvmLock = new ReentrantLock();  
  52.         }  
  53.   
  54.         @Override  
  55.         public void run() {  
  56.             //(1)首先判断缓存内资源是否存在  
  57.             if(redis.get(key) == null) {  
  58.                 try {  
  59.                       
  60.                     //这里延时1000毫秒的目的是防止线程过快的更新资源，那么其它线程在步骤(1)处就返回true了.  
  61.                     Thread.sleep(1000);  
  62.                       
  63.                     //获取JVM锁(同一进程内有效)  
  64.                     jvmLock.lock();  
  65.                       
  66.                     //(2)再次判断资源是否已经存在  
  67.                     if(redis.get(key) == null) {  
  68.                         System.out.println("线程:" + Thread.currentThread() + "获取到JVM锁，redis.get(key)为空, 准备获取ZK锁");  
  69.                           
  70.                         //这里延时500毫秒的目的是防止线程过快更新资源，其它线程在步骤(2)就返回true了。  
  71.                         Thread.sleep(500);  
  72.                         try {  
  73.                             //获取zk分布式锁  
  74.                             distributedLock.acquire();  
  75.                             System.out.println("线程:" + Thread.currentThread() + "获取到JVM锁，redis.get(key)为空, 获取到了ZK锁");  
  76.   
  77.                             //再次判断,若是为空这时能够更新资源  
  78.                             if(redis.get(key) == null) {  
  79.                                 redis.put(key, Thread.currentThread() + "更新了缓存");  
  80.                                 System.out.println("线程:" + Thread.currentThread() + "更新了缓存");  
  81.                             } else {  
  82.                                 System.out.println("线程:" + Thread.currentThread() + "当前资源已经存在，不须要更新");  
  83.                             }  
  84.                         } catch (Exception e) {  
  85.                             e.printStackTrace();  
  86.                         } finally {  
  87.                             //释放ZK锁  
  88.                             try {  
  89.                                 distributedLock.release();  
  90.                             } catch (Exception e) {  
  91.                                 e.printStackTrace();  
  92.                             }  
  93.                         }  
  94.                     } else {  
  95.                         System.out.println("线程:" + Thread.currentThread() + "获取到JVM锁，redis.get(key)不为空," + redis.get(key));  
  96.                     }  
  97.                 } catch (InterruptedException e) {  
  98.                     e.printStackTrace();  
  99.                 } finally {  
  100.                     //释放JVM锁  
  101.                     jvmLock.unlock();  
  102.                 }  
  103.             } else {  
  104.                 System.out.println(redis.get(key));  
  105.             }  
  106.         }  
  107.     }  
  108.   
  109. }  



 

 

线程:Thread[pool-5-thread-2,5,main]获取到JVM锁，redis.get(key)为空, 准备获取ZK锁
线程:Thread[pool-5-thread-3,5,main]获取到JVM锁，redis.get(key)为空, 准备获取ZK锁
线程:Thread[pool-5-thread-3,5,main]获取到JVM锁，redis.get(key)为空, 获取到了ZK锁
线程:Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-7,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-1,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-5,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-9,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-23,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-19,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-11,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-31,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-35,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-15,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-27,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-25,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-33,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-37,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-13,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-17,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-2,5,main]获取到JVM锁，redis.get(key)为空, 获取到了ZK锁
线程:Thread[pool-5-thread-2,5,main]当前资源已经存在，不须要更新
线程:Thread[pool-5-thread-21,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-29,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-55,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-59,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-41,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-67,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-39,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-43,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-57,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-47,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-51,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-63,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-8,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-69,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-4,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-6,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-10,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-22,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-16,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-20,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-45,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-24,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-32,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-36,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-49,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-28,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-12,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-14,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-26,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-53,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-18,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-61,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-30,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-65,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-34,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-97,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-40,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-91,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-64,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-42,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-46,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-50,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-87,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-85,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-44,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-75,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-48,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-71,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-77,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-52,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-99,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-93,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-56,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-60,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-95,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-89,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-81,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-73,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-68,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-58,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-62,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-66,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-38,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-54,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-94,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-83,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-96,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-79,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-92,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-90,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-80,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-82,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-72,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-78,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-100,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-70,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-88,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-84,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-98,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-86,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-76,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存
线程:Thread[pool-5-thread-74,5,main]获取到JVM锁，redis.get(key)不为空,Thread[pool-5-thread-3,5,main]更新了缓存

咱们经过观察日志，发现只有2个次须要获取分布式锁，其它的都被JVM锁给阻挡在外面了，在这种状况下能够大大的提升锁的性能。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程