diff --git a/redisson/src/main/java/org/redisson/RedissonListMultimap.java b/redisson/src/main/java/org/redisson/RedissonListMultimap.java
index ca73597d1..b752efd6f 100644
--- a/redisson/src/main/java/org/redisson/RedissonListMultimap.java
+++ b/redisson/src/main/java/org/redisson/RedissonListMultimap.java
@@ -189,6 +189,30 @@ public class RedissonListMultimap<K, V> extends RedissonMultimap<K, V> implement
 
         return new RedissonList<V>(codec, commandExecutor, setName, null) {
             
+            @Override
+            public RFuture<Boolean> addAsync(V value) {
+                return RedissonListMultimap.this.putAsync(key, value);
+            }
+            
+            @Override
+            public RFuture<Boolean> addAllAsync(Collection<? extends V> c) {
+                return RedissonListMultimap.this.putAllAsync(key, c);
+            }
+            
+            @Override
+            public RFuture<Boolean> removeAsync(Object value) {
+                return RedissonListMultimap.this.removeAsync(key, value);
+            }
+            
+            @Override
+            public RFuture<Boolean> removeAllAsync(Collection<?> c) {
+                ByteBuf keyState = encodeMapKey(key);
+                return commandExecutor.evalWriteAsync(RedissonListMultimap.this.getName(), codec, RedisCommands.EVAL_BOOLEAN,
+                        "redis.call('hdel', KEYS[1], ARGV[1]); " +
+                        "return redis.call('del', KEYS[2]) > 0; ",
+                    Arrays.<Object>asList(RedissonListMultimap.this.getName(), setName), keyState);
+            }
+            
             @Override
             public RFuture<Boolean> deleteAsync() {
                 ByteBuf keyState = encodeMapKey(key);
diff --git a/redisson/src/main/java/org/redisson/RedissonSetMultimap.java b/redisson/src/main/java/org/redisson/RedissonSetMultimap.java
index d29aa265e..8f02137dc 100644
--- a/redisson/src/main/java/org/redisson/RedissonSetMultimap.java
+++ b/redisson/src/main/java/org/redisson/RedissonSetMultimap.java
@@ -167,6 +167,30 @@ public class RedissonSetMultimap<K, V> extends RedissonMultimap<K, V> implements
 
         return new RedissonSet<V>(codec, commandExecutor, setName, null) {
             
+            @Override
+            public RFuture<Boolean> addAsync(V value) {
+                return RedissonSetMultimap.this.putAsync(key, value);
+            }
+            
+            @Override
+            public RFuture<Boolean> addAllAsync(Collection<? extends V> c) {
+                return RedissonSetMultimap.this.putAllAsync(key, c);
+            }
+            
+            @Override
+            public RFuture<Boolean> removeAsync(Object value) {
+                return RedissonSetMultimap.this.removeAsync(key, value);
+            }
+            
+            @Override
+            public RFuture<Boolean> removeAllAsync(Collection<?> c) {
+                ByteBuf keyState = encodeMapKey(key);
+                return commandExecutor.evalWriteAsync(RedissonSetMultimap.this.getName(), codec, RedisCommands.EVAL_BOOLEAN_AMOUNT,
+                        "redis.call('hdel', KEYS[1], ARGV[1]); " +
+                        "return redis.call('del', KEYS[2]); ",
+                    Arrays.<Object>asList(RedissonSetMultimap.this.getName(), setName), keyState);
+            }
+            
             @Override
             public RFuture<Boolean> deleteAsync() {
                 ByteBuf keyState = encodeMapKey(key);
diff --git a/redisson/src/test/java/org/redisson/RedissonSetMultimapTest.java b/redisson/src/test/java/org/redisson/RedissonSetMultimapTest.java
index 3036e3e49..35b93e9fe 100644
--- a/redisson/src/test/java/org/redisson/RedissonSetMultimapTest.java
+++ b/redisson/src/test/java/org/redisson/RedissonSetMultimapTest.java
@@ -117,6 +117,91 @@ public class RedissonSetMultimapTest extends BaseTest {
 
     }
 
+    @Test
+    public void testGetAdd() {
+        RSetMultimap<String, Integer> multimap1 = redisson.getSetMultimap("myMultimap1");
+        Set<Integer> one = multimap1.get("1");
+        Set<Integer> two = multimap1.get("2");
+        Set<Integer> four = multimap1.get("4");
+        one.add(1);
+        one.add(2);
+        one.add(3);
+        two.add(5);
+        two.add(6);
+        four.add(7);
+        
+        assertThat(multimap1.keySet()).containsOnly("1", "2", "4");
+        assertThat(multimap1.keySize()).isEqualTo(3);
+        assertThat(multimap1.get("1")).containsOnly(1, 2, 3);
+        assertThat(multimap1.get("2")).containsOnly(5, 6);
+        assertThat(multimap1.get("4")).containsOnly(7);
+    }
+
+    @Test
+    public void testGetAddAll() {
+        RSetMultimap<String, Integer> multimap1 = redisson.getSetMultimap("myMultimap1");
+        Set<Integer> one = multimap1.get("1");
+        Set<Integer> two = multimap1.get("2");
+        Set<Integer> four = multimap1.get("4");
+        one.addAll(Arrays.asList(1, 2, 3));
+        two.addAll(Arrays.asList(5, 6));
+        four.addAll(Arrays.asList(7));
+        
+        assertThat(multimap1.keySet()).containsOnly("1", "2", "4");
+        assertThat(multimap1.keySize()).isEqualTo(3);
+        assertThat(multimap1.get("1")).containsOnly(1, 2, 3);
+        assertThat(multimap1.get("2")).containsOnly(5, 6);
+        assertThat(multimap1.get("4")).containsOnly(7);
+    }
+
+    
+    @Test
+    public void testGetRemove() {
+        RSetMultimap<String, Integer> multimap1 = redisson.getSetMultimap("myMultimap1");
+        Set<Integer> one = multimap1.get("1");
+        Set<Integer> two = multimap1.get("2");
+        Set<Integer> four = multimap1.get("4");
+        one.add(1);
+        one.add(2);
+        one.add(3);
+        two.add(5);
+        two.add(6);
+        four.add(7);
+        
+        assertThat(one.remove(1)).isTrue();
+        assertThat(one.remove(2)).isTrue();
+        assertThat(two.remove(5)).isTrue();
+        assertThat(four.remove(7)).isTrue();
+        
+        assertThat(multimap1.keySet()).containsOnly("1", "2");
+        assertThat(multimap1.keySize()).isEqualTo(2);
+        assertThat(multimap1.get("1")).containsOnly(3);
+        assertThat(multimap1.get("2")).containsOnly(6);
+    }
+
+    @Test
+    public void testGetRemoveAll() {
+        RSetMultimap<String, Integer> multimap1 = redisson.getSetMultimap("myMultimap1");
+        Set<Integer> one = multimap1.get("1");
+        Set<Integer> two = multimap1.get("2");
+        Set<Integer> four = multimap1.get("4");
+        one.add(1);
+        one.add(2);
+        one.add(3);
+        two.add(5);
+        two.add(6);
+        four.add(7);
+        
+        assertThat(one.removeAll(Arrays.asList(1, 2, 3))).isTrue();
+        assertThat(two.removeAll(Arrays.asList(5, 6))).isTrue();
+        assertThat(four.removeAll(Arrays.asList(7))).isTrue();
+        assertThat(four.removeAll(Arrays.asList(9))).isFalse();
+        
+        assertThat(multimap1.keySet()).isEmpty();
+        assertThat(multimap1.keySize()).isEqualTo(0);
+    }
+
+    
     @Test
     public void testSize() {
         RSetMultimap<SimpleKey, SimpleValue> map = redisson.getSetMultimap("test1");