Springboot-Redisson - 6.分布式集合

👀 分布式集合

名称	作用	使用场景	优点	缺点	Redisson调用的方法
映射 (Map)	存储键值对	数据存储、缓存	快速查找、高并发	内存占用	getMap, put, get
映射的元素淘汰 (Eviction)	自动移除旧数据	内存优化	自动管理内存	可能导致数据丢失	put with maxIdleTime
映射的本地缓存 (LocalCache)	本地存储热数据	提高数据访问速度	快速访问	可能导致数据不一致	RLocalCachedMap
映射的数据分片 (Sharding)	将数据分布在多个节点上	分布式存储、负载均衡	扩展性、高可用性	维护复杂	透明处理
映射持久化方式 (缓存策略)	将数据持久存储到磁盘	数据安全、备份	数据安全	性能开销	Redis配置
映射监听器 (Map Listener)	监听映射的数据更改	事件驱动的应用、实时通知	实时反应	额外的资源消耗	addListener
LRU有界映射	使用LRU策略的有限大小的映射	缓存	自动淘汰老数据、内存管理	有大小限制	RLocalCachedMap with LRU
多值映射 (Multimap)	一个键多个值	一对多数据关系	灵活数据存储	内存占用	getSetMultimap, put, get
基于集 (Set) 的多值映射	使用Set存储多个值	去重的一对多数据关系	无重复数据存储	不能存储重复数据	getSetMultimap
基于列表 (List) 的多值映射	使用List存储多个值	有序的一对多数据关系	有序数据存储	内存占用	getListMultimap
多值映射的元素淘汰 (Eviction)	自动移除旧数据	内存优化	自动管理内存	可能导致数据丢失	put with maxIdleTime
集 (Set)	存储无重复的元素	去重	快速查找、自动去重	不能存储重复元素	RSet
集的淘汰机制 (Eviction)	自动移除旧数据	内存优化	自动管理内存	可能导致数据丢失	配置TTL或MaxIdleTime
集的数据分片 (Sharding)	将数据分布在多个节点	分布式存储、负载均衡	扩展性、高可用性	维护复杂	透明处理
有序集 (SortedSet)	存储有序的无重复元素	排序数据存储	有序、自动去重	性能开销	RSortedSet
计分排序集 (ScoredSortedSet)	元素与分数关联的有序集	排行榜等	按分数有序、灵活	性能开销	RScoredSortedSet
字典排序集 (LexSortedSet)	字典顺序的有序集	字符串排序	字符串有序	字符串限制	RLexSortedSet
列表 (List)	有序可重复的元素集合	有序数据存储	有序、灵活	内存占用	RList
队列 (Queue)	先进先出数据结构	任务队列、消息传递	有序、实时处理	可能导致资源竞争	RQueue
双端队列 (Deque)	两端都可以添加或删除的队列	特定场景的数据处理	更灵活	更复杂的API	RDeque
阻塞队列 (Blocking Queue)	当队列为空或满时线程会阻塞	多线程任务处理	线程安全、流量控制	可能导致线程阻塞	RBlockingQueue
有界阻塞队列 (Bounded Blocking Queue)	有限大小的线程安全队列	多线程任务处理、流量控制	线程安全、自动大小管理	有大小限制、可能导致线程阻塞	RBoundedBlockingQueue
阻塞双端队列 (Blocking Deque)	两端都可以操作并线程安全的队列	特定场景的多线程数据处理	灵活、线程安全	可能导致线程阻塞	RBlockingDeque
阻塞公平队列 (Blocking Fair Queue)	线程安全并确保所有线程公平访问的队列	公平处理多线程任务	公平性、线程安全	性能开销	不直接支持，需要自定义逻辑
阻塞公平双端队列 (Blocking Fair Deque)	两端公平并线程安全的队列	公平处理特定场景的多线程任务	公平性、灵活、线程安全	性能开销	不直接支持，需要自定义逻辑
延迟队列 (Delayed Queue)	在指定延迟后才能访问的元素的队列	定时任务、任务调度	精确延迟、线程安全	性能开销	RDelayedQueue
优先队列 (Priority Queue)	元素有优先级的队列	优先任务处理	按优先级排序、灵活	性能开销	RPriorityQueue
优先双端队列 (Priority Deque)	两端都可以操作并有优先级的队列	优先处理特定场景的任务	按优先级排序、灵活	性能开销	不直接支持，需要自定义逻辑
优先阻塞队列 (Priority Blocking Queue)	有优先级并线程安全的队列	优先多线程任务处理	按优先级排序、线程安全	可能导致线程阻塞	RPriorityBlockingQueue
优先阻塞双端队列 (Priority Blocking Deque)	两端有优先级并线程安全的队列	优先处理特定场景的多线程任务	按优先级排序、线程安全、灵活	可能导致线程阻塞	不直接支持，需要自定义逻辑

✌ 映射（Map）

✍ 映射（Map）的元素淘汰（Eviction），本地缓存（LocalCache）和数据分片（Sharding）

🎷作用

• 元素淘汰：在Map达到一定大小时，自动删除某些元素。
• 本地缓存：对于频繁访问的元素，可以在本地进行缓存，减少网络调用。
• 数据分片：将数据均匀地分布在多个Redis实例上。

🎷使用场景

• 对于大数据集，需要动态管理其大小。
• 高并发的Spring Boot应用，需要减少对Redis的访问频率。
• 使用Redis集群时，均衡数据存储。

🎷优缺点

优点：提高性能和可扩展性，有效管理存储。
缺点：增加了配置和管理的复杂性。

🎷示例

import org.redisson.api.RedissonClient;
import org.redisson.api.RMap;
import org.redisson.api.map.options.MapOptions;

@Service
public class AdvancedMapService {
    @Autowired
    private RedissonClient redisson;

    public void putToEvictingMap(String key, String value) {
        RMap<String, String> map = redisson.getMap("evictingMap", MapOptions.defaults().maxSize(1000));
        map.put(key, value);
    }
}

✍ 映射持久化方式（缓存策略）

🎷作用

决定数据在Redis中的存储方式和持久化策略，例如，数据可以存储在内存中并在磁盘上进行持久化。

🎷使用场景

• 当数据的安全性和持久性比速度更重要时。
• 当需要备份或迁移数据时。

🎷优缺点

优点：提供数据安全性，防止数据丢失。
缺点：可能会影响性能，增加存储成本。

🎷示例

在Redis配置中，可以通过以下设置来启用RDB持久化：

save 900 1
save 300 10
save 60 10000
rdbcompression yes

✍ 映射监听器（Map Listener）

🎷作用

映射监听器允许开发者监听映射中的数据变化，如添加、删除或修改条目。

🎷使用场景

• 当需要在数据变化时执行某些操作。
• 监控或日志记录。

🎷优缺点

优点：提供对数据变化的实时响应。
缺点：如果监听器处理时间过长，可能会对性能产生影响。

🎷示例

import org.redisson.api.RMap;
import org.redisson.api.map.MapListener;
import org.redisson.api.map.event.EntryCreatedEvent;

@Service
public class MapListenerService {
    @Autowired
    private RedissonClient redisson;

    public void addListener() {
        RMap<String, String> map = redisson.getMap("myMap");
        map.addListener(new MapListener<String, String>() {
            @Override
            public void onCreated(EntryCreatedEvent<String, String> event) {
                System.out.println("Entry created: " + event.getKey() + " = " + event.getValue());
            }
        });
    }
}

明白了，我将为您提供关于LRU有界映射的详细内容，结合Spring Boot和Redisson。

---

✍ LRU有界映射

🎷作用

LRU (Least Recently Used) 有界映射是一个大小固定的映射。当映射满时，它会自动淘汰最近最少使用的元素。这种策略确保映射中的数据是最近访问过的，从而使缓存更为高效。

🎷使用场景

• 在Spring Boot应用中缓存经常访问的数据，但受限于有限的缓存空间。
• 当需要一个自动管理其大小的缓存解决方案时。
• 对于访问模式中存在明显的局部性原理的场景，例如页面缓存、图片缓存等。

🎷优缺点

优点：自动管理内存，确保最有价值的数据被保留，有效地利用有限的缓存空间。
缺点：可能会导致不经常访问但仍然重要的数据被淘汰。

🎷示例

在Spring Boot结合Redisson使用LRU有界映射：

import org.redisson.api.RedissonClient;
import org.redisson.api.RMapCache;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class LruBoundedMapService {

    @Autowired
    private RedissonClient redisson;

    public void putToLruBoundedMap(String key, String value) {
        RMapCache<String, String> map = redisson.getMapCache("lruBoundedMap");
        // 设置该映射的最大大小
        map.setMaxSize(1000);
        // 添加数据并设置TTL为10分钟
        map.put(key, value, 10, TimeUnit.MINUTES);
    }

    public String getFromLruBoundedMap(String key) {
        RMapCache<String, String> map = redisson.getMapCache("lruBoundedMap");
        return map.get(key);
    }
}

在这个示例中，我们使用RMapCache来实现LRU有界映射。通过setMaxSize方法，我们可以设置映射的最大大小。当映射达到这个大小时，最近最少使用的元素会被自动淘汰。

了解，按照您的新要求，我将提供关于多值映射（Multimap）及其子标题的详细内容，结合Spring Boot和Redisson。

---

✌ 多值映射（Multimap）

✍ 基于集（Set）的多值映射（Multimap）

🎷作用

使用Set作为值的容器，确保每个键的所有值都是唯一的。

🎷使用场景

• 当需要确保每个键的所有值都是唯一的，例如，一个用户的多个唯一的邮件地址。

🎷优缺点

优点：确保数据的唯一性。
缺点：不能有重复的值。

🎷示例

@Service
public class SetMultimapService {

    @Autowired
    private RedissonClient redisson;

    public void addToSetMultimap(String key, String value) {
        RSetMultimap<String, String> multimap = redisson.getSetMultimap("mySetMultimap");
        multimap.put(key, value);
    }
}

✍ 基于列表（List）的多值映射（Multimap）

🎷作用

使用List作为值的容器，允许每个键有重复的值。

🎷使用场景

• 当需要记录每个键的所有值，包括重复的值，例如，用户的所有订单。

🎷优缺点

优点：能够存储重复的值。
缺点：需要更多的存储空间。

🎷示例

import org.redisson.api.RListMultimap;

@Service
public class ListMultimapService {

    @Autowired
    private RedissonClient redisson;

    public void addToListMultimap(String key, String value) {
        RListMultimap<String, String> multimap = redisson.getListMultimap("myListMultimap");
        multimap.put(key, value);
    }
}

✍ 多值映射（Multimap）淘汰机制（Eviction）

🎷作用

当多值映射达到一定的大小或存储时间时，自动删除某些元素。

🎷使用场景

• 当需要管理缓存大小或存储时间，例如，用户的临时会话数据。

🎷优缺点

优点：自动管理存储，防止数据过度膨胀。
缺点：可能导致重要数据的丢失。

🎷示例

为了实现多值映射（Multimap）的淘汰机制（Eviction），我们可以使用Redisson提供的RMapCache或RSetCache。这些结构支持带有TTL（生存时间）的条目，当达到指定的生存时间后，这些条目会被自动淘汰。以下是使用Redisson和Spring Boot实现多值映射（Multimap）淘汰机制的示例。

import org.redisson.api.RMapCache;
import org.redisson.api.RSetCache;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

@Service
public class MultimapEvictionService {

    @Autowired
    private RedissonClient redisson;

    // 使用RMapCache实现多值映射的淘汰机制
    public void addToMapWithEviction(String key, String value) {
        RMapCache<String, String> map = redisson.getMapCache("myEvictingMap");
        // 将条目放入映射中，并设置10分钟的生存时间
        map.put(key, value, 10, TimeUnit.MINUTES);
    }

    // 使用RSetCache实现多值映射的淘汰机制
    public void addToSetWithEviction(String key, String value) {
        RSetCache<String> set = redisson.getSetCache("myEvictingSet:" + key);
        // 将条目放入集合中，并设置10分钟的生存时间
        set.add(value, 10, TimeUnit.MINUTES);
    }
}

在这个示例中，我们使用了RMapCache和RSetCache。这些数据结构的条目都可以带有生存时间，这使得在达到指定的生存时间后，它们会被自动淘汰。这种方法提供了一种简单有效的淘汰机制，而无需进行额外的操作。

好的，接下来我将为您提供有关集（Set）及其子标题的详细内容，结合Spring Boot和Redisson。

---

✌ 集（Set）

✍作用

集（Set）在Redisson中提供了一个无序且不包含重复元素的集合。它允许进行添加、删除、检查和遍历元素的操作。

✍使用场景

• 存储无需关心顺序和不希望有重复元素的数据，例如用户的唯一ID集合。
• 在Spring Boot应用中实现功能，如实时的黑名单或白名单。

✍优缺点

优点：快速的数据插入和查询，自动处理重复数据。
缺点：不保留数据的插入顺序。

✍示例

import org.redisson.api.RSet;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class SetService {

    @Autowired
    private RedissonClient redisson;

    public void addToSet(String value) {
        RSet<String> set = redisson.getSet("mySet");
        set.add(value);
    }

    public boolean checkInSet(String value) {
        RSet<String> set = redisson.getSet("mySet");
        return set.contains(value);
    }
}

✍ 集（Set）淘汰机制（Eviction）

🎷作用

为集合中的元素设置生存时间，使其在达到指定的生存时间后被自动淘汰。

🎷使用场景

• 当需要存储临时数据，例如会话ID或临时令牌，并希望它们在一段时间后自动过期。

🎷优缺点

优点：自动管理数据的生命周期，节省存储空间。
缺点：需要额外的配置和注意，以确保不会意外地删除重要数据。

🎷示例

import org.redisson.api.RSetCache;
import java.util.concurrent.TimeUnit;

@Service
public class SetEvictionService {

    @Autowired
    private RedissonClient redisson;

    public void addToSetWithEviction(String value) {
        RSetCache<String> set = redisson.getSetCache("myEvictingSet");
        // 添加数据并设置10分钟的生存时间
        set.add(value, 10, TimeUnit.MINUTES);
    }
}

✍ 集（Set）数据分片（Sharding）

🎷作用

将数据均匀地分布在多个Redis实例上，以提高扩展性和性能。

🎷使用场景

• 当集合的大小非常大，无法放入单个Redis实例时。
• 当需要提高数据读写性能时。

🎷优缺点

优点：提高性能和扩展性，均衡地利用所有Redis实例。
缺点：增加了配置和管理的复杂性。

🎷示例

在Redisson中，通过配置Redis集群模式或使用多个Redis实例，数据会自动进行分片。您只需正常使用RSet，Redisson会处理数据分片的部分。

@Service
public class SetShardingService {

    @Autowired
    private RedissonClient redisson;

    public void addToShardedSet(String value) {
        RSet<String> set = redisson.getSet("myShardedSet");
        set.add(value);
    }
}

好的，我将为您提供有关有序集（SortedSet）、计分排序集（ScoredSortedSet）和字典排序集（LexSortedSet）的详细内容，结合Spring Boot和Redisson。

---

✌ 有序集（SortedSet）

✍作用

有序集（SortedSet）是一个不包含重复元素且其元素按某种方式排序的集合。

✍使用场景

• 存储需要排序的数据，例如，按日期排序的事件。
• 在Spring Boot应用中实现功能，如排行榜。

✍优缺点

优点：保证数据的有序性，便于查询。
缺点：插入和删除数据可能比普通集合慢，因为需要保持排序。

✍示例

import org.redisson.api.RSortedSet;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class SortedSetService {

    @Autowired
    private RedissonClient redisson;

    public void addToSortedSet(String value) {
        RSortedSet<String> set = redisson.getSortedSet("mySortedSet");
        set.add(value);
    }

    public String getFirstInSortedSet() {
        RSortedSet<String> set = redisson.getSortedSet("mySortedSet");
        return set.first();
    }
}

✌ 计分排序集（ScoredSortedSet）

✍作用

计分排序集是一种特殊类型的有序集，在此集合中，每个元素都与一个“分数”相关联，集合是根据这些分数排序的。

✍使用场景

• 存储需要根据某个属性排序的数据，例如，用户的分数或评级。
• 在Spring Boot应用中实现功能，如积分榜。

✍优缺点

优点：可以快速地按分数获取元素。
缺点：需要管理和更新每个元素的分数。

✍示例

import org.redisson.api.RScoredSortedSet;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class ScoredSortedSetService {

    @Autowired
    private RedissonClient redisson;

    public void addToScoredSortedSet(String value, double score) {
        RScoredSortedSet<String> set = redisson.getScoredSortedSet("myScoredSortedSet");
        set.add(score, value);
    }

    public String getTopInScoredSortedSet() {
        RScoredSortedSet<String> set = redisson.getScoredSortedSet("myScoredSortedSet");
        return set.first();
    }
}

✌ 字典排序集（LexSortedSet）

✍作用

字典排序集是一种特殊类型的有序集，集合中的元素按照字典序排序。

✍使用场景

• 存储需要按字母顺序排序的数据，例如，字典或名称列表。
• 在Spring Boot应用中实现功能，如自动完成或拼写检查。

✍优缺点

优点：快速查询和按字典顺序获取元素。
缺点：只能排序字符串类型的元素。

✍示例

import org.redisson.api.RLexSortedSet;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class LexSortedSetService {

    @Autowired
    private RedissonClient redisson;

    public void addToLexSortedSet(String value) {
        RLexSortedSet set = redisson.getLexSortedSet("myLexSortedSet");
        set.add(value);
    }

    public String getFirstInLexSortedSet() {
        RLexSortedSet set = redisson.getLexSortedSet("myLexSortedSet");
        return set.first();
    }
}

✌ 列表（List）

✍作用

列表（List）在Redisson中提供了一个有序的元素集合。它允许在列表的任何位置进行元素的插入和删除。

✍使用场景

• 存储有序的数据，例如用户的购物车项目。
• 在Spring Boot应用中实现功能，如用户的动态或时间线。

✍优缺点

优点：灵活的数据插入和查询。
缺点：可能需要更多的存储空间和处理时间，特别是当列表很大时。

✍示例

import org.redisson.api.RList;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class ListService {

    @Autowired
    private RedissonClient redisson;

    public void addToList(String value) {
        RList<String> list = redisson.getList("myList");
        list.add(value);
    }
}

✌ 队列（Queue）

✍作用

队列提供了一个先进先出（FIFO）的数据结构，用于存储和检索数据。

✍使用场景

• 实现任务队列或消息队列。
• 在Spring Boot应用中，为后台处理提供任务。

✍优缺点

优点：确保数据的处理顺序。
缺点：只能从队列的一端插入和另一端删除数据。

✍示例

import org.redisson.api.RQueue;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class QueueService {

    @Autowired
    private RedissonClient redisson;

    public void addToQueue(String value) {
        RQueue<String> queue = redisson.getQueue("myQueue");
        queue.add(value);
    }

    public String retrieveFromQueue() {
        RQueue<String> queue = redisson.getQueue("myQueue");
        return queue.poll();
    }
}

✌ 双端队列（Deque）

✍作用

双端队列允许在两端进行元素的插入和删除。

✍使用场景

• 实现一个双向滚动的列表。
• 在Spring Boot应用中，为后台处理提供优先级任务。

✍优缺点

优点：提供了更多的灵活性。
缺点：管理可能比简单的队列更复杂。

✍示例

import org.redisson.api.RDeque;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class DequeService {

    @Autowired
    private RedissonClient redisson;

    public void addToFront(String value) {
        RDeque<String> deque = redisson.getDeque("myDeque");
        deque.addFirst(value);
    }

    public void addToEnd(String value) {
        RDeque<String> deque = redisson.getDeque("myDeque");
        deque.addLast(value);
    }
}

✌ 阻塞队列（Blocking Queue）

✍作用

阻塞队列在尝试检索或添加元素时，如果队列为空或已满，它会使线程等待。

✍使用场景

• 实现生产者-消费者模式。
• 在Spring Boot应用中，为异步处理提供任务，并确保线程安全。

✍优缺点

优点：确保线程安全，避免资源竞争。
缺点：可能导致线程阻塞，降低性能。

✍示例

import org.redisson.api.RBlockingQueue;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class BlockingQueueService {

    @Autowired
    private RedissonClient redisson;

    public void addToBlockingQueue(String value) throws InterruptedException {
        RBlockingQueue<String> queue = redisson.getBlockingQueue("myBlockingQueue");
        queue.put(value);
    }

    public String retrieveFromBlockingQueue() throws InterruptedException {
        RBlockingQueue<String> queue = redisson.getBlockingQueue("myBlockingQueue");
        return queue.take();
    }
}

✌ 有界阻塞队列（Bounded Blocking Queue）

✍作用

有界阻塞队列是一个大小固定的队列。当队列满时，添加元素的操作会被阻塞；当队列空时，取出元素的操作会被阻塞。

✍使用场景

• 控制内存使用量，防止过多的数据积压。
• 实现生产者-消费者模式，其中生产和消费的速率可能不同。

✍优缺点

优点：防止资源过度使用，确保线程安全。
缺点：当队列达到其最大大小时，进一步的插入操作会被阻塞。

✍示例

import org.redisson.api.RBoundedBlockingQueue;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class BoundedBlockingQueueService {

    @Autowired
    private RedissonClient redisson;

    public void addToBoundedQueue(String value) throws InterruptedException {
        RBoundedBlockingQueue<String> queue = redisson.getBoundedBlockingQueue("myBoundedQueue");
        queue.trySetCapacity(1000);  // 设置队列的最大容量
        queue.put(value);
    }
}

✌ 阻塞双端队列（Blocking Deque）

✍作用

阻塞双端队列允许从两端插入和删除元素，如果队列为空或已满，相关操作会被阻塞。

✍使用场景

• 双向工作队列，例如处理双向消息传递。

✍优缺点

优点：提供了更多的灵活性，确保线程安全。
缺点：可能导致线程阻塞，降低性能。

✍示例

import org.redisson.api.RBlockingDeque;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class BlockingDequeService {

    @Autowired
    private RedissonClient redisson;

    public void addToBlockingDequeFront(String value) throws InterruptedException {
        RBlockingDeque<String> deque = redisson.getBlockingDeque("myBlockingDeque");
        deque.putFirst(value);
    }

    public void addToBlockingDequeEnd(String value) throws InterruptedException {
        RBlockingDeque<String> deque = redisson.getBlockingDeque("myBlockingDeque");
        deque.putLast(value);
    }
}

✌ 阻塞公平队列（Blocking Fair Queue）

✍作用

阻塞公平队列确保所有线程都能公平地访问队列，防止线程饥饿。

✍使用场景

• 在多线程环境中，确保所有线程都能公平地处理任务。

✍优缺点

优点：确保所有线程公平访问，防止线程饥饿。
缺点：可能导致性能开销。

✍示例（该功能仅限于Redisson PRO版本。）

基于Redis的Redisson分布式无界阻塞公平队列（Blocking Fair Queue）结构的RBlockingFairQueue Java对象在实现Redisson分布式无界阻塞队列（Blocking Queue）结构RBlockingQueue接口的基础上，解决了多个队列消息的处理者在复杂的网络环境下，网络延时的影响使“较远”的客户端最终收到消息数量低于“较近”的客户端的问题。从而解决了这种现象引发的个别处理节点过载的情况。

以分布式无界阻塞队列为基础，采用公平获取消息的机制，不仅保证了poll、pollFromAny、pollLastAndOfferFirstTo和take方法获取消息的先入顺序，还能让队列里的消息被均匀的发布到处在复杂分布式环境中的各个处理节点里。

RBlockingFairQueue queue = redisson.getBlockingFairQueue("myQueue");
queue.offer(new SomeObject());

SomeObject obj = queue.peek();
SomeObject someObj = queue.poll();
SomeObject ob = queue.poll(10, TimeUnit.MINUTES);

✌ 阻塞公平双端队列（Blocking Fair Deque）

✍作用

阻塞公平双端队列确保从两端进行操作的线程都能公平地访问队列。

✍使用场景

• 在多线程环境中，确保所有线程都能公平地从队列的两端处理任务。

✍优缺点

优点：确保所有线程公平访问，提供双端操作的灵活性。
缺点：可能导致性能开销。

✍示例（该功能仅限于Redisson PRO版本。）

基于Redis的Redisson分布式无界阻塞公平双端队列（Blocking Fair Deque）结构的RBlockingFairDeque Java对象在实现Redisson分布式无界阻塞双端队列（Blocking Deque）结构RBlockingDeque接口的基础上，解决了多个队列消息的处理者在复杂的网络环境下，网络延时的影响使“较远”的客户端最终收到消息数量低于“较近”的客户端的问题。从而解决了这种现象引发的个别处理节点过载的情况。

以分布式无界阻塞双端队列为基础，采用公平获取消息的机制，不仅保证了poll、take、pollFirst、takeFirst、pollLast和takeLast方法获取消息的先入顺序，还能让队列里的消息被均匀的发布到处在复杂分布式环境中的各个处理节点里。

RBlockingFairDeque deque = redisson.getBlockingFairDeque("myDeque");
deque.offer(new SomeObject());

SomeObject firstElement = queue.peekFirst();
SomeObject firstElement = queue.pollFirst();
SomeObject firstElement = queue.pollFirst(10, TimeUnit.MINUTES);
SomeObject firstElement = queue.takeFirst();

SomeObject lastElement = queue.peekLast();
SomeObject lastElement = queue.pollLast();
SomeObject lastElement = queue.pollLast(10, TimeUnit.MINUTES);
SomeObject lastElement = queue.takeLast();

✌ 延迟队列（Delayed Queue）

✍作用

延迟队列允许您在指定的延迟后获取元素，而不是立即获取。

✍使用场景

• 定时任务或任务调度。
• 消息的延时处理。
• 缓存过期。

✍优缺点

优点：提供定时处理功能，无需外部调度。
缺点：需要额外的内部机制来支持延迟。

✍示例

import org.redisson.api.RDelayedQueue;
import org.redisson.api.RQueue;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;

@Service
public class DelayedQueueService {

    @Autowired
    private RedissonClient redisson;

    public void addToDelayedQueue(String item) {
        RQueue<String> queue = redisson.getQueue("anyQueue");
        RDelayedQueue<String> delayedQueue = redisson.getDelayedQueue(queue);
        // 延迟10分钟添加元素到队列
        delayedQueue.offer(item, 10, TimeUnit.MINUTES);
    }
}

✌ 优先队列（Priority Queue）

✍作用

优先队列允许您根据元素的优先级进行处理，而不是它们的到达顺序。

✍使用场景

• 任务调度。
• 数据压缩算法。
• 路径查找。

✍优缺点

优点：提供优先级处理。
缺点：需要定义元素的比较方式。

✍示例

注意：Redisson 的优先队列默认使用 Java 的 Comparator 来确定优先级。

import org.redisson.api.RPriorityQueue;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class PriorityQueueService {

    @Autowired
    private RedissonClient redisson;

    public void addToPriorityQueue(String item) {
        RPriorityQueue<String> queue = redisson.getPriorityQueue("anyQueue");
        queue.add(item);
    }
}

✌ 优先双端队列（Priority Deque）

此数据结构在 Redisson 中没有直接的实现。但可以通过组合其他数据结构来实现。（该功能仅限于Redisson PRO版本。）

✌ 优先阻塞队列（Priority Blocking Queue）

✍作用

优先阻塞队列结合了优先队列和阻塞队列的特性，允许根据优先级处理元素，并在必要时阻塞操作。

✍使用场景

• 多线程中的任务调度。
• 系统中断处理。

✍优缺点

优点：提供了优先级和阻塞两个功能。
缺点：需要定义元素的比较方式。

✍示例

与优先队列类似，Redisson 的优先阻塞队列默认使用 Java 的 Comparator 来确定优先级。

import org.redisson.api.RPriorityBlockingQueue;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class PriorityBlockingQueueService {

    @Autowired
    private RedissonClient redisson;

    public void addToPriorityBlockingQueue(String item) {
        RPriorityBlockingQueue<String> queue = redisson.getPriorityBlockingQueue("anyQueue");
        queue.add(item);
    }
}

✌ 优先阻塞双端队列（Priority Blocking Deque）

与优先双端队列类似，此数据结构在 Redisson 中没有直接的实现，但可以通过组合其他数据结构来实现。（该功能仅限于Redisson PRO版本。）