缓存击穿解决方案(互斥锁+双端检查机制)的优化

互斥锁+双端检查机制方案

  • 原方案中,synchronized的锁对象为UserServiceImpl.class(即当前接口实现类)
  • 该方案中,不论查询的key是什么,synchronized锁对象都为UserServiceImpl.class
public UserInfo getUserByIdFirstRedis(Integer id) {
        UserInfo userInfo;
        String key = "user_" + id;
        userInfo = (UserInfo) redisTemplate.opsForValue().get(key);
        if (null == userInfo || userInfo.getId() == 0) {
            // 锁对象为 UserServiceImpl.class(即当前接口实现类)
            synchronized (UserServiceImpl.class) {
                // 再次检查,防止线程获取到锁后,redis中已经存在数据
                userInfo = (UserInfo) redisTemplate.opsForValue().get(key);
                if (null == userInfo || userInfo.getId() == 0) {
                    System.out.println(Thread.currentThread().getName() + " =》实际请求MySQL");
                    userInfo = userDao.getById(id);
                    redisTemplate.opsForValue().set(key, userInfo);
                }
            }
        }
        return userInfo;
    } 

互斥锁+双端检查机制方案的优化

  • 优化点:降低synchronized的锁对象,即减小锁的粒度
  • 原方案中,synchronized锁对象是UserServiceImpl.class,故不论哪个key进来,都需要排队等待锁
  • 优化后,synchronized锁对象优化为缓存key相同key排队等待锁,不同key可以并发请求更新redis数据,提高了并发度
  • 难点:如何让每个请求进来,同样的变量参数,能够获取到同一个key锁对象
    • 方案:利用字符串常量池,将参数变量生成的key放到字符串常量池中,后续只要key相同,都会返回常量池中的同一个String对象
public UserInfo getUserByIdFirstRedis(Integer id) {
        UserInfo userInfo;
        // 把key放到字符串常量池中,这样并发线程进入后,可以获取同一个字符串常量对象
        String key = ("user_" + id).intern();
        userInfo = (UserInfo) redisTemplate.opsForValue().get(key);
        if (null == userInfo || userInfo.getId() == 0) {
            // 这里是互斥锁,让每个key的查询,只有一个线程进入并打到MySQL上
            // 由于key是在字符串常量池中,故同一个key获取的是字符串常量池对象
            synchronized (key) {
                // 再次检查,防止线程获取到锁后,redis中已经存在数据
                userInfo = (UserInfo) redisTemplate.opsForValue().get(key);
                if (null == userInfo || userInfo.getId() == 0) {
                    System.out.println(Thread.currentThread().getName() + " =》实际请求MySQL");
                    userInfo = userDao.getById(id);
                    redisTemplate.opsForValue().set(key, userInfo);
                }
            }
        }
        return userInfo;
    }

测试

  • 2个key,同时发出1000个线程请求,对比两个方案的执行时间
  • 同时检测优化后的方案是否会出现锁不住情况
public void getUserByIdFirstRedis() {
		// 利用CountDownLatch等待2个key执行完成
        CountDownLatch count1 = new CountDownLatch(1000);
        CountDownLatch count2 = new CountDownLatch(1000);
        long s = System.currentTimeMillis();

		// key = 1
        for (int i = 0; i < 1000; i++) {
            new Thread(() -> {
                userService.getUserByIdFirstRedis(1);
                count1.countDown();
            }, "t1::" + i).start();
        }
        // key = 2
        for (int i = 0; i < 1000; i++) {
            new Thread(() -> {
                userService.getUserByIdFirstRedis(2);
                count2.countDown();
            }, "t2=》" + i).start();
        }
        try {
            count1.await();
            count2.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("总耗时 =》" + (System.currentTimeMillis() - s));
    }
时间对比
  • synchronized (UserServiceImpl.class)执行时间1204毫秒
    在这里插入图片描述
  • synchronized (key)执行时间993毫秒
    在这里插入图片描述
synchronized (key)是否能锁住
  • 从上面中可以看出,synchronized (UserServiceImpl.class)只有2个线程请求到了MySQL
  • synchronized (key)也是只有2个线程请求到了MySQL,故能锁住
  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
### 回答1: Linux下的进程间通信(IPC)方式有很多种,其中无亲缘关系的进程间通信方式包括互斥锁、条件变量和共享内存。 互斥锁是一种保护共享资源不被并发访问的机制。当进程需要访问共享资源时,它会尝试获取互斥锁。如果锁已经被其他进程占用,则进程会被阻塞,直到锁被释放。这样可以确保同一时间只有一个进程能够访问共享资源,从而避免了竞争条件和数据不一致的问题。 条件变量是一种进程间通信方式,用于线程同步和条件同步。使用条件变量可以实现进程的等待和唤醒操作,从而控制进程的执行顺序。当一个进程需要等待某个条件成立时,它会调用条件变量的等待操作,该操作会阻塞进程并释放对共享资源的占用。当条件满足时,其他进程可以通过唤醒操作通知等待的进程继续执行。 共享内存是一种能够在不同进程之间共享数据的机制。通过共享内存,可以将一块内存空间映射到不同的进程地址空间,从而实现进程间的数据共享。多个进程可以直接访问共享内存,从而实现高效的数据传递。但需要注意的是,由于共享内存不提供进程间同步和互斥机制,因此在使用共享内存进行进程间通信时,需要结合其他同步机制(如互斥锁)确保数据的一致性和正确性。 综上所述,互斥锁、条件变量和共享内存是Linux下无亲缘关系的进程间通信的重要方式。通过这些方式,进程可以进行数据共享和同步,从而实现协作和协同操作。但在使用这些机制时,需要注意进程同步和互斥的问题,以确保数据的正确性和一致性。 ### 回答2: Linux中的进程间通信(IPC)是指不同进程之间进行数据交换和共享资源的方法。在Linux中,有多种IPC机制可以实现进程间的通信,包括管道、消息队列、信号量、共享内存和套接字等。其中,互斥锁、条件变量和共享内存是常用的进程间通信方式。 互斥锁是一种同步原语,用于保护共享资源的访问。当一个进程正在使用共享资源时,可以通过申请互斥锁来锁定资源,防止其他进程同时访问。只有当拥有互斥锁的进程释放锁时,其他进程才能竞争获取锁。 条件变量通常与互斥锁一起使用,用于实现在特定条件下的线程等待和唤醒操作。一个进程可以通过条件变量来等待某个特定条件的发生,如果条件不满足,则该进程将等待在条件变量上。当另一个进程满足了条件并发送了信号时,该进程就会被唤醒。 共享内存是一种用于实现进程间数据共享的技术。它允许多个进程直接访问同一块内存区域,而无需进行数据的拷贝和传输。进程可以通过映射共享内存到自己的地址空间上来实现对共享内存区域的访问。在使用共享内存时,需要使用互斥锁等同步机制来保证多个进程对于共享内存的访问是安全的。 总之,互斥锁、条件变量和共享内存是Linux中常用的进程间通信方式,它们通过提供同步机制和共享资源访问的方法,实现了不同进程之间的数据交换和资源共享。这些机制在多进程编程中非常重要,可以有效提高程序的并发性能和效率。 ### 回答3: 在Linux下,无亲缘关系的进程间通信可以利用互斥锁、条件变量和共享内存来实现。以下是对每种通信方式的详细描述: 1. 互斥锁互斥锁是一种用于保护共享资源的同步机制,确保在同一时刻只有一个进程可以访问被保护的资源。在无亲缘关系的进程间通信中,可以使用互斥锁实现对共享资源的互斥访问。当一个进程想要访问共享资源时,它会先检查互斥锁的状态。如果互斥锁已被其他进程持有,则该进程将被阻塞,直到互斥锁变为可用状态。一旦该进程获得互斥锁,它就可以访问共享资源,完成操作后释放互斥锁。 2. 条件变量:条件变量用于进程间的协调和同步。当一个进程需要等待某个条件满足时,它可以通过条件变量来进行等待,并在条件变量满足时被唤醒。在无亲缘关系的进程间通信中,可以使用条件变量实现多个进程之间的等待和唤醒机制。当一个进程需要等待某个条件满足时,它可以调用等待函数,将自己放入条件变量的等待队列中并阻塞。当另一个进程满足了条件后,它可以通过唤醒函数来通知等待的进程,使其重新运行。 3. 共享内存:共享内存是一种让多个进程可以访问同一块内存区域的方式。在无亲缘关系的进程间通信中,可以使用共享内存实现进程间的数据共享。多个进程可以将需要共享的数据映射到同一块共享内存区域,并利用该内存区域进行数据的读写操作。通过共享内存,进程可以直接读写共享数据,而无需通过其他的通信机制。此外,为了保证数据的一致性和并发访问的正确性,通常还需要使用互斥锁或其他同步机制来控制对共享内存的访问。 综上所述,Linux提供了互斥锁、条件变量和共享内存这几种机制来实现无亲缘关系的进程间通信,进程可以通过这些通信方式来进行资源的互斥访问、进程之间的协调和同步,以及共享数据的传递。通过合理地选择和使用这些通信方式,可以实现高效、可靠的进程间通信。
评论 3
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值