redisson中如何使用分布式集合

這篇文章將為大家詳細(xì)講解有關(guān)redisson中如何使用分布式集合，文章內(nèi)容質(zhì)量較高，因此小編分享給大家做個(gè)參考，希望大家閱讀完這篇文章后對相關(guān)知識有一定的了解。

redisson分布式集合

1.映射（Map）

Redisson的分布式Map結(jié)構(gòu)的RMap Java對象實(shí)現(xiàn)了java.util.concurrent.ConcurrentMap接口和java.util.Map接口。同時(shí)還保持了元素的插入順序。該對象的最大容量受Redis限制，最大元素?cái)?shù)量是4 294 967 295個(gè)。

RMap<String, SomeObject> map = redisson.getMap("anyMap");
SomeObject prevObject = map.put("123", new SomeObject());
SomeObject currentObject = map.putIfAbsent("323", new SomeObject());
SomeObject obj = map.remove("123");

map.fastPut("321", new SomeObject());
map.fastRemove("321");

Future<SomeObject> putAsyncFuture = map.putAsync("321");
Future<Void> fastPutAsyncFuture = map.fastPutAsync("321");

map.fastPutAsync("321", new SomeObject());
map.fastRemoveAsync("321");

1.1. 映射（Map）淘汰機(jī)制（Eviction）

Redisson的分布式的RMapCache Java對象在基于RMap的前提下實(shí)現(xiàn)了針對單個(gè)元素的淘汰機(jī)制。同時(shí)仍然保留了元素的插入順序。由于RMapCache是基于RMap實(shí)現(xiàn)的，使它同時(shí)繼承了java.util.concurrent.ConcurrentMap接口和java.util.Map接口。Redisson提供的Spring Cache整合 正是基于這樣的對象結(jié)構(gòu)來實(shí)現(xiàn)的。

目前的Redis自身并不支持哈希（Hash）當(dāng)中的元素淘汰，因此所有過期元素都是通過org.redisson.EvictionScheduler實(shí)例來實(shí)現(xiàn)定期清理的。為了保證資源的有效利用，每次運(yùn)行最多清理100個(gè)過期元素。任務(wù)的啟動時(shí)間將根據(jù)上次實(shí)際清理數(shù)量自動調(diào)整，間隔時(shí)間趨于1秒到2小時(shí)之間。比如該次清理時(shí)刪除了100條元素，那么下次執(zhí)行清理的時(shí)間將在1秒以后（最小間隔時(shí)間）。一旦該次清理數(shù)量少于上次清理數(shù)量，時(shí)間間隔將增加1.5倍。

RMapCache<String, SomeObject> map = redisson.getMapCache("anyMap");
// 有效時(shí)間 ttl = 10分鐘
map.put("key1", new SomeObject(), 10, TimeUnit.MINUTES);
// 有效時(shí)間 ttl = 10分鐘, 最長閑置時(shí)間 maxIdleTime = 10秒鐘
map.put("key1", new SomeObject(), 10, TimeUnit.MINUTES, 10, TimeUnit.SECONDS);

// 有效時(shí)間 = 3 秒鐘
map.putIfAbsent("key2", new SomeObject(), 3, TimeUnit.SECONDS);
// 有效時(shí)間 ttl = 40秒鐘, 最長閑置時(shí)間 maxIdleTime = 10秒鐘
map.putIfAbsent("key2", new SomeObject(), 40, TimeUnit.SECONDS, 10, TimeUnit.SECONDS);

1.2 本地緩存映射（LocalCachedMap）

在特定的場景下，高度頻繁的讀取操作讓網(wǎng)絡(luò)通信都被視為瓶頸的情況時(shí)，使用Redisson提供的分布式Map本地緩存RLocalCachedMapJava對象會是一個(gè)很好的選擇。RLocalCachedMap會根據(jù)配置參數(shù)，針對一個(gè)分布式Map中元素的進(jìn)行有條件緩存，從而實(shí)現(xiàn)高效率的讀取操作。以下配置參數(shù)可以用來創(chuàng)建這個(gè)實(shí)例：

LocalCachedMapOptions options = LocalCachedMapOptions.defaults()
      // 淘汰機(jī)制有LFU, LRU和NONE這幾種算法策略可供選擇
     .evictionPolicy(EvictionPolicy.LFU)
     .cacheSize(1000)
      // 如果該值是`真(true)`時(shí)，在該實(shí)例執(zhí)行更新和刪除操作的同時(shí)，將向其他所有的相同實(shí)例發(fā)
      // 送針對該元素的淘汰消息。其他相同實(shí)例在收到該消息以后，會同時(shí)刪除自身的緩存。下次讀取
      // 該元素時(shí)會從Redis服務(wù)器獲取。
     .invalidateEntryOnChange(false)
      // 每個(gè)Map本地緩存里元素的有效時(shí)間，默認(rèn)毫秒為單位
     .timeToLive(10000)
      // 或者
     .timeToLive(10, TimeUnit.SECONDS)
      // 每個(gè)Map本地緩存里元素的最長閑置時(shí)間，默認(rèn)毫秒為單位
     .maxIdle(10000)
      // 或者
     .maxIdle(10, TimeUnit.SECONDS);
RLocalCachedMap<String, Integer> map = redisson.getLocalCachedMap("test", options);

map.put("1", 1);
map.put("2", 2);

map.fastPut("3", 4);
當(dāng)不再使用Map本地緩存對象的時(shí)候應(yīng)該自行手動銷毀，如果Redisson對象被關(guān)閉（shutdown）了，則不用手動銷毀。

RLocalCachedMap<String, Integer> map = ...
map.destroy();

1.3. 映射（Map）數(shù)據(jù)分片

Map數(shù)據(jù)分片是Redis集群模式下的一個(gè)功能。Redisson提供的分布式RClusteredMap Java對象也是基于RMap實(shí)現(xiàn)的。在這里可以獲取更多的信息。

RClusteredMap<String, SomeObject> map = redisson.getClusteredMap("anyMap");

SomeObject prevObject = map.put("123", new SomeObject());
SomeObject currentObject = map.putIfAbsent("323", new SomeObject());
SomeObject obj = map.remove("123");

map.fastPut("321", new SomeObject());
map.fastRemove("321");

當(dāng)使用RClusteredMap在特定的場景下，高度頻繁的讀取操作讓網(wǎng)絡(luò)通信都被視為瓶頸的情況時(shí)，使用Redisson提供的集群模式下的分布式Map本地緩存RClusteredLocalCachedMapJava對象會是一個(gè)很好的選擇。RClusteredLocalCachedMap會根據(jù)配置參數(shù)，針對一個(gè)集群模式下的分布式Map中元素的進(jìn)行有條件緩存，從而實(shí)現(xiàn)高效率的讀取操作。以下配置參數(shù)可以用來創(chuàng)建這個(gè)實(shí)例：

LocalCachedMapOptions options = LocalCachedMapOptions.defaults()
      // LFU, LRU and NONE policies are available
     .evictionPolicy(EvictionPolicy.LFU)
     .cacheSize(1000)
      // 如果該值是`真(true)`時(shí)，在該實(shí)例執(zhí)行更新和刪除操作的同時(shí)，將向其他所有的相同實(shí)例發(fā)
      // 送針對該元素的淘汰消息。其他相同實(shí)例在收到該消息以后，會同時(shí)刪除自身的緩存。下次讀取
      // 該元素時(shí)會從Redis服務(wù)器獲取。
     .invalidateEntryOnChange(false)
      // 每個(gè)Map本地緩存里元素的有效時(shí)間，默認(rèn)毫秒為單位
     .timeToLive(10000)
      // 或者
     .timeToLive(10, TimeUnit.SECONDS)
      // 每個(gè)Map本地緩存里元素的最長閑置時(shí)間，默認(rèn)毫秒為單位
     .maxIdle(10000)
      // 或者
     .maxIdle(10, TimeUnit.SECONDS);
RClusteredLocalCachedMap<String, Integer> map = redisson.getClusteredLocalCachedMap("test", options);
        
map.put("1", 1);
map.put("2", 2);

map.fastPut("3", 4);

當(dāng)不再使用Map本地緩存對象的時(shí)候應(yīng)該自行手動銷毀，如果Redisson對象被關(guān)閉（shutdown）了，則不用手動銷毀。

RClusteredLocalCachedMap<String, Integer> map = ...
map.destroy();

除了RClusteredLocalCachedMap以外，Redisson還提供了另一種集群模式下的分布式映射（Map），它不僅提供了透明的數(shù)據(jù)分片功能，還為每個(gè)元素提供了淘汰機(jī)制。RClusteredMapCache類分別同時(shí)提供了RClusteredMap和RMapCache這兩個(gè)接口的實(shí)現(xiàn)。與RClusteredLocalCachedMap不同的是，前者的淘汰機(jī)制是針對保持在Redis里的元素而言的，而后者的淘汰機(jī)制是針對的本地緩存里的元素而言。

RClusteredMapCache<String, SomeObject> map = redisson.getClusteredMapCache("anyMap");
// 有效時(shí)間 ttl = 10分鐘
map.put("key1", new SomeObject(), 10, TimeUnit.MINUTES);
// 有效時(shí)間 ttl = 10分鐘, 最長閑置時(shí)間 maxIdleTime = 10秒鐘
map.put("key1", new SomeObject(), 10, TimeUnit.MINUTES, 10, TimeUnit.SECONDS);

// 有效時(shí)間 = 3 秒鐘
map.putIfAbsent("key2", new SomeObject(), 3, TimeUnit.SECONDS);
// 有效時(shí)間 ttl = 40秒鐘, 最長閑置時(shí)間 maxIdleTime = 10秒鐘
map.putIfAbsent("key2", new SomeObject(), 40, TimeUnit.SECONDS, 10, TimeUnit.SECONDS);

該功能僅限于Redisson PRO版本。

2. 多值映射（Multimap）

Redisson的分布式RMultimap Java對象允許Map中的一個(gè)字段值包含多個(gè)元素。 字段總數(shù)受Redis限制，每個(gè)Multimap最多允許有4 294 967 295個(gè)不同字段。

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

基于Set的Multimap不允許一個(gè)字段值包含有重復(fù)的元素。

RSetMultimap<SimpleKey, SimpleValue> map = redisson.getSetMultimap("myMultimap");
map.put(new SimpleKey("0"), new SimpleValue("1"));
map.put(new SimpleKey("0"), new SimpleValue("2"));
map.put(new SimpleKey("3"), new SimpleValue("4"));

Set<SimpleValue> allValues = map.get(new SimpleKey("0"));

List<SimpleValue> newValues = Arrays.asList(new SimpleValue("7"), new SimpleValue("6"), new SimpleValue("5"));
Set<SimpleValue> oldValues = map.replaceValues(new SimpleKey("0"), newValues);

Set<SimpleValue> removedValues = map.removeAll(new SimpleKey("0"));

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

基于List的Multimap在保持插入順序的同時(shí)允許一個(gè)字段下包含重復(fù)的元素。

RListMultimap<SimpleKey, SimpleValue> map = redisson.getListMultimap("test1");
map.put(new SimpleKey("0"), new SimpleValue("1"));
map.put(new SimpleKey("0"), new SimpleValue("2"));
map.put(new SimpleKey("0"), new SimpleValue("1"));
map.put(new SimpleKey("3"), new SimpleValue("4"));

List<SimpleValue> allValues = map.get(new SimpleKey("0"));

Collection<SimpleValue> newValues = Arrays.asList(new SimpleValue("7"), new SimpleValue("6"), new SimpleValue("5"));
List<SimpleValue> oldValues = map.replaceValues(new SimpleKey("0"), newValues);

List<SimpleValue> removedValues = map.removeAll(new SimpleKey("0"));

2.3. 多值映射（Multimap）淘汰機(jī)制（Eviction）

Multimap對象的淘汰機(jī)制是通過不同的接口來實(shí)現(xiàn)的。它們是RSetMultimapCache接口和RListMultimapCache接口，分別對應(yīng)的是Set和List的Multimaps。

所有過期元素都是通過org.redisson.EvictionScheduler實(shí)例來實(shí)現(xiàn)定期清理的。為了保證資源的有效利用，每次運(yùn)行最多清理100個(gè)過期元素。任務(wù)的啟動時(shí)間將根據(jù)上次實(shí)際清理數(shù)量自動調(diào)整，間隔時(shí)間趨于1秒到2小時(shí)之間。比如該次清理時(shí)刪除了100條元素，那么下次執(zhí)行清理的時(shí)間將在1秒以后（最小間隔時(shí)間）。一旦該次清理數(shù)量少于上次清理數(shù)量，時(shí)間間隔將增加1.5倍。

RSetMultimapCache的使用范例：

RSetMultimapCache<String, String> multimap = redisson.getSetMultimapCache("myMultimap");
multimap.put("1", "a");
multimap.put("1", "b");
multimap.put("1", "c");

multimap.put("2", "e");
multimap.put("2", "f");

multimap.expireKey("2", 10, TimeUnit.MINUTES);

3.集（Set）

Redisson的分布式Set結(jié)構(gòu)的RSet Java對象實(shí)現(xiàn)了java.util.Set接口。通過元素的相互狀態(tài)比較保證了每個(gè)元素的唯一性。該對象的最大容量受Redis限制，最大元素?cái)?shù)量是4 294 967 295個(gè)。

RSet<SomeObject> set = redisson.getSet("anySet");
set.add(new SomeObject());
set.remove(new SomeObject());

Redisson PRO版本中的Set對象還可以在Redis集群環(huán)境下支持單集合數(shù)據(jù)分片。

3.1. 集（Set）淘汰機(jī)制（Eviction）

Redisson的分布式RSetCache Java對象在基于RSet的前提下實(shí)現(xiàn)了針對單個(gè)元素的淘汰機(jī)制。由于RSetCache是基于RSet實(shí)現(xiàn)的，使它還集成了java.util.Set接口。

目前的Redis自身并不支持Set當(dāng)中的元素淘汰，因此所有過期元素都是通過org.redisson.EvictionScheduler實(shí)例來實(shí)現(xiàn)定期清理的。為了保證資源的有效利用，每次運(yùn)行最多清理100個(gè)過期元素。任務(wù)的啟動時(shí)間將根據(jù)上次實(shí)際清理數(shù)量自動調(diào)整，間隔時(shí)間趨于1秒到2小時(shí)之間。比如該次清理時(shí)刪除了100條元素，那么下次執(zhí)行清理的時(shí)間將在1秒以后（最小間隔時(shí)間）。一旦該次清理數(shù)量少于上次清理數(shù)量，時(shí)間間隔將增加1.5倍。

RSetCache<SomeObject> set = redisson.getSetCache("anySet");
// ttl = 10 seconds
set.add(new SomeObject(), 10, TimeUnit.SECONDS);

3.2. 集（Set）數(shù)據(jù)分片

Set數(shù)據(jù)分片是Redis集群模式下的一個(gè)功能。Redisson提供的分布式RClusteredSet Java對象也是基于RSet實(shí)現(xiàn)的。在這里可以獲取更多的信息。

RClusteredSet<SomeObject> set = redisson.getClusteredSet("anySet");
set.add(new SomeObject());
set.remove(new SomeObject());

除了RClusteredSet以外，Redisson還提供了另一種集群模式下的分布式集（Set），它不僅提供了透明的數(shù)據(jù)分片功能，還為每個(gè)元素提供了淘汰機(jī)制。RClusteredSetCache類分別同時(shí)提供了RClusteredSet和RSetCache這兩個(gè)接口的實(shí)現(xiàn)。當(dāng)然這些都是基于java.util.Set的接口實(shí)現(xiàn)上的。

該功能僅限于Redisson PRO版本。

4. 有序集（SortedSet）

Redisson的分布式RSortedSet Java對象實(shí)現(xiàn)了java.util.SortedSet接口。在保證元素唯一性的前提下，通過比較器（Comparator）接口實(shí)現(xiàn)了對元素的排序。

RSortedSet<Integer> set = redisson.getSortedSet("anySet");
set.trySetComparator(new MyComparator()); // 配置元素比較器
set.add(3);
set.add(1);
set.add(2);

set.removeAsync(0);
set.addAsync(5);

5. 計(jì)分排序集（ScoredSortedSet）

Redisson的分布式RScoredSortedSet Java對象是一個(gè)可以按插入時(shí)指定的元素評分排序的集合。它同時(shí)還保證了元素的唯一性。

RScoredSortedSet<SomeObject> set = redisson.getScoredSortedSet("simple");

set.add(0.13, new SomeObject(a, b));
set.addAsync(0.251, new SomeObject(c, d));
set.add(0.302, new SomeObject(g, d));

set.pollFirst();
set.pollLast();

int index = set.rank(new SomeObject(g, d)); // 獲取元素在集合中的位置
Double score = set.getScore(new SomeObject(g, d)); // 獲取元素的評分

6. 字典排序集（LexSortedSet）

Redisson的分布式RLexSortedSet Java對象在實(shí)現(xiàn)了java.util.Set<String>接口的同時(shí)，將其中的所有字符串元素按照字典順序排列。它公式還保證了字符串元素的唯一性。

RLexSortedSet set = redisson.getLexSortedSet("simple");
set.add("d");
set.addAsync("e");
set.add("f");

set.lexRangeTail("d", false);
set.lexCountHead("e");
set.lexRange("d", true, "z", false);

7. 列表（List)

Redisson分布式列表（List）結(jié)構(gòu)的RList Java對象在實(shí)現(xiàn)了java.util.List接口的同時(shí)，確保了元素插入時(shí)的順序。該對象的最大容量受Redis限制，最大元素?cái)?shù)量是4 294 967 295個(gè)。

RList<SomeObject> list = redisson.getList("anyList");
list.add(new SomeObject());
list.get(0);
list.remove(new SomeObject());

8. 列隊(duì)（Queue）

Redisson分布式無界列隊(duì)（Queue）結(jié)構(gòu)的RQueue Java對象實(shí)現(xiàn)了java.util.Queue接口。盡管RQueue對象無初始大?。ㄟ吔纾┫拗?，但對象的最大容量受Redis限制，最大元素?cái)?shù)量是4 294 967 295個(gè)。

RQueue<SomeObject> queue = redisson.getQueue("anyQueue");
queue.add(new SomeObject());
SomeObject obj = queue.peek();
SomeObject someObj = queue.poll();

9. 雙端隊(duì)列（Deque）

Redisson分布式無界雙端隊(duì)列（Deque）結(jié)構(gòu)的RDeque Java對象實(shí)現(xiàn)了java.util.Deque接口。盡管RDeque對象無初始大?。ㄟ吔纾┫拗疲珜ο蟮淖畲笕萘渴躌edis限制，最大元素?cái)?shù)量是4 294 967 295個(gè)。

RDeque<SomeObject> queue = redisson.getDeque("anyDeque");
queue.addFirst(new SomeObject());
queue.addLast(new SomeObject());
SomeObject obj = queue.removeFirst();
SomeObject someObj = queue.removeLast();

10. 阻塞隊(duì)列（Blocking Queue）

Redisson分布式無界阻塞隊(duì)列（Blocking Queue）結(jié)構(gòu)的RBlockingQueue Java對象實(shí)現(xiàn)了java.util.concurrent.BlockingQueue接口。盡管RBlockingQueue對象無初始大小（邊界）限制，但對象的最大容量受Redis限制，最大元素?cái)?shù)量是4 294 967 295個(gè)。

RBlockingQueue<SomeObject> queue = redisson.getBlockingQueue("anyQueue");
queue.offer(new SomeObject());

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

poll, pollFromAny, pollLastAndOfferFirstTo和take方法內(nèi)部采用話題訂閱發(fā)布實(shí)現(xiàn)，在Redis節(jié)點(diǎn)故障轉(zhuǎn)移（主從切換）或斷線重連以后，內(nèi)置的相關(guān)話題監(jiān)聽器將自動完成話題的重新訂閱。

11. 有界阻塞列隊(duì)（Bounded Blocking Queue）

Redisson分布式有界阻塞列隊(duì)（Bounded Blocking Queue）結(jié)構(gòu)的RBoundedBlockingQueue Java對象實(shí)現(xiàn)了java.util.concurrent.BlockingQueue接口。該對象的最大容量受Redis限制，最大元素?cái)?shù)量是4 294 967 295個(gè)。列隊(duì)的初始容量（邊界）必須在使用前設(shè)定好。

RBoundedBlockingQueue<SomeObject> queue = redisson.getBoundedBlockingQueue("anyQueue");
// 如果初始容量（邊界）設(shè)定成功則返回`真（true）`，
// 如果初始容量（邊界）已近存在則返回`假（false）`。
queue.trySetCapacity(2);

queue.offer(new SomeObject(1));
queue.offer(new SomeObject(2));
// 此時(shí)容量已滿，下面代碼將會被阻塞，直到有空閑為止。
queue.put(new SomeObject());

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

poll, pollFromAny, pollLastAndOfferFirstTo和take方法內(nèi)部采用話題訂閱發(fā)布實(shí)現(xiàn)，在Redis節(jié)點(diǎn)故障轉(zhuǎn)移（主從切換）或斷線重連以后，內(nèi)置的相關(guān)話題監(jiān)聽器將自動完成話題的重新訂閱。

12. 阻塞雙端列隊(duì)（Blocking Deque）

Redisson分布式無界阻塞雙端列隊(duì)（Blocking Deque）結(jié)構(gòu)的RBlockingDeque Java對象實(shí)現(xiàn)了java.util.concurrent.BlockingDeque接口。盡管RBlockingDeque對象無初始大?。ㄟ吔纾┫拗?，但對象的最大容量受Redis限制，最大元素?cái)?shù)量是4 294 967 295個(gè)。

RBlockingDeque<Integer> deque = redisson.getBlockingDeque("anyDeque");
deque.putFirst(1);
deque.putLast(2);
Integer firstValue = queue.takeFirst();
Integer lastValue = queue.takeLast();
Integer firstValue = queue.pollFirst(10, TimeUnit.MINUTES);
Integer lastValue = queue.pollLast(3, TimeUnit.MINUTES);

poll, pollFromAny, pollLastAndOfferFirstTo和take方法內(nèi)部采用話題訂閱發(fā)布實(shí)現(xiàn)，在Redis節(jié)點(diǎn)故障轉(zhuǎn)移（主從切換）或斷線重連以后，內(nèi)置的相關(guān)話題監(jiān)聽器將自動完成話題的重新訂閱。

13. 阻塞公平列隊(duì)（Blocking Fair Queue）

Redisson分布式無界阻塞公平列隊(duì)（Blocking Fair Queue）結(jié)構(gòu)的RBlockingFairQueue Java對象在實(shí)現(xiàn)Redisson分布式無界阻塞隊(duì)列（Blocking Queue）結(jié)構(gòu)RBlockingQueue接口的基礎(chǔ)上，解決了多個(gè)列隊(duì)消息的處理者在復(fù)雜的網(wǎng)絡(luò)環(huán)境下，網(wǎng)絡(luò)延時(shí)的影響使“較遠(yuǎn)”的客戶端最終收到消息數(shù)量低于“較近”的客戶端的問題。從而解決了這種現(xiàn)象引發(fā)的個(gè)別處理節(jié)點(diǎn)過載的情況。

以分布式無界阻塞隊(duì)列為基礎(chǔ)，采用公平獲取消息的機(jī)制，不僅保證了poll和take方法獲取消息的先入順序，還能讓列隊(duì)里的消息被均勻的發(fā)布到處在復(fù)雜分布式環(huán)境中的各個(gè)處理節(jié)點(diǎn)里。

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

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

14. 延遲列隊(duì)（Delayed Queue）

Redisson分布式延遲列隊(duì)（Delayed Queue）結(jié)構(gòu)的RDelayedQueue Java對象在實(shí)現(xiàn)了RQueue接口的基礎(chǔ)上提供了向列隊(duì)按要求延遲添加項(xiàng)目的功能。該功能可以用來實(shí)現(xiàn)消息傳送延遲按幾何增長或幾何衰減的發(fā)送策略。

RQueue<String> distinationQueue = ...
RDelayedQueue<String> delayedQueue = getDelayedQueue(distinationQueue);
// 10秒鐘以后將消息發(fā)送到指定列隊(duì)
delayedQueue.offer("msg1", 10, TimeUnit.SECONDS);
// 一分鐘以后將消息發(fā)送到指定列隊(duì)
delayedQueue.offer("msg2", 1, TimeUnit.MINUTES);
在該對象不再需要的情況下，應(yīng)該主動銷毀。僅在相關(guān)的Redisson對象也需要關(guān)閉的時(shí)候可以不用主動銷毀。

RDelayedQueue<String> delayedQueue = ...
delayedQueue.destroy();

15. 優(yōu)先隊(duì)列（Priority Queue）

基于Redis的分布式優(yōu)先隊(duì)列（Priority Queue）Java對象實(shí)現(xiàn)了java.util.Queue的接口。可以通過比較器（Comparator）接口來對元素排序。

RPriorityQueue<Integer> queue = redisson.getPriorityQueue("anyQueue");
queue.trySetComparator(new MyComparator()); // 指定對象比較器
queue.add(3);
queue.add(1);
queue.add(2);

queue.removeAsync(0);
queue.addAsync(5);

queue.poll();

16. 優(yōu)先雙端隊(duì)列（Priority Deque）

基于Redis的分布式優(yōu)先雙端隊(duì)列（Priority Deque）Java對象實(shí)現(xiàn)了java.util.Deque的接口?？梢酝ㄟ^比較器（Comparator）接口來對元素排序。

RPriorityDeque<Integer> queue = redisson.getPriorityDeque("anyQueue");
queue.trySetComparator(new MyComparator()); // 指定對象比較器
queue.addLast(3);
queue.addFirst(1);
queue.add(2);

queue.removeAsync(0);
queue.addAsync(5);

queue.pollFirst();
queue.pollLast();

關(guān)于redisson中如何使用分布式集合就分享到這里了，希望以上內(nèi)容可以對大家有一定的幫助，可以學(xué)到更多知識。如果覺得文章不錯(cuò)，可以把它分享出去讓更多的人看到。