org.redisson.RedissonBoundedBlockingQueue Maven / Gradle / Ivy
Show all versions of redisson-all Show documentation
/**
* Copyright (c) 2013-2024 Nikita Koksharov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.redisson;
import org.redisson.api.Entry;
import org.redisson.api.RBoundedBlockingQueue;
import org.redisson.api.RFuture;
import org.redisson.api.RedissonClient;
import org.redisson.client.codec.Codec;
import org.redisson.client.codec.LongCodec;
import org.redisson.client.protocol.RedisCommand;
import org.redisson.client.protocol.RedisCommands;
import org.redisson.command.CommandAsyncExecutor;
import org.redisson.connection.decoder.ListDrainToDecoder;
import org.redisson.misc.CompletableFutureWrapper;
import java.time.Duration;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionException;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.TimeUnit;
import java.util.function.Consumer;
import java.util.function.Function;
/**
* Distributed and concurrent implementation of bounded {@link java.util.concurrent.BlockingQueue}.
*
* @author Nikita Koksharov
*/
public class RedissonBoundedBlockingQueue extends RedissonQueue implements RBoundedBlockingQueue {
private final RedissonBlockingQueue blockingQueue;
private final RedissonQueueSemaphore semaphore;
private final String channelName;
private final String semaphoreName;
protected RedissonBoundedBlockingQueue(CommandAsyncExecutor commandExecutor, String name, RedissonClient redisson) {
super(commandExecutor, name, redisson);
blockingQueue = new RedissonBlockingQueue<>(commandExecutor, name, redisson);
semaphoreName = getSemaphoreName(getRawName());
semaphore = new RedissonQueueSemaphore(commandExecutor, semaphoreName, getServiceManager().getCfg().getCodec());
channelName = RedissonSemaphore.getChannelName(semaphore.getRawName());
}
protected RedissonBoundedBlockingQueue(Codec codec, CommandAsyncExecutor commandExecutor, String name, RedissonClient redisson) {
super(codec, commandExecutor, name, redisson);
blockingQueue = new RedissonBlockingQueue<>(commandExecutor, name, redisson);
semaphoreName = getSemaphoreName(getRawName());
semaphore = new RedissonQueueSemaphore(commandExecutor, semaphoreName, codec);
channelName = RedissonSemaphore.getChannelName(semaphore.getRawName());
}
private String getSemaphoreName(String name) {
return prefixName("redisson_bqs", name);
}
@Override
public RFuture addAsync(V e) {
RFuture future = offerAsync(e);
CompletionStage f = future.handle((res, ex) -> {
if (ex != null) {
throw new CompletionException(ex);
}
if (!res) {
throw new CompletionException(new IllegalStateException("Queue is full"));
}
return true;
});
return new CompletableFutureWrapper<>(f);
}
@Override
public RFuture putAsync(V e) {
RedissonQueueSemaphore semaphore = createSemaphore(e);
return semaphore.acquireAsync();
}
private RedissonQueueSemaphore createSemaphore(V e) {
RedissonQueueSemaphore semaphore = new RedissonQueueSemaphore(commandExecutor, semaphoreName, getCodec());
semaphore.setQueueName(getRawName());
semaphore.setValue(e);
return semaphore;
}
@Override
public void put(V e) throws InterruptedException {
RedissonQueueSemaphore semaphore = createSemaphore(e);
semaphore.acquire();
}
@Override
public RFuture offerAsync(V e) {
RedissonQueueSemaphore semaphore = createSemaphore(e);
return semaphore.tryAcquireAsync();
}
@Override
public boolean offer(V e, long timeout, TimeUnit unit) throws InterruptedException {
RedissonQueueSemaphore semaphore = createSemaphore(e);
return semaphore.tryAcquire(timeout, unit);
}
@Override
public RFuture offerAsync(V e, long timeout, TimeUnit unit) {
RedissonQueueSemaphore semaphore = createSemaphore(e);
return semaphore.tryAcquireAsync(timeout, unit);
}
@Override
public RFuture takeAsync() {
RFuture takeFuture = blockingQueue.takeAsync();
return wrapTakeFuture(takeFuture);
}
private RFuture wrapTakeFuture(RFuture takeFuture) {
CompletionStage f = takeFuture.thenCompose(res -> {
if (res == null) {
return CompletableFuture.completedFuture(null);
}
return createSemaphore(null).releaseAsync().handle((r, ex) -> res);
});
f.whenComplete((r, e) -> {
if (f.toCompletableFuture().isCancelled()) {
takeFuture.cancel(false);
}
});
return new CompletableFutureWrapper<>(f);
}
@Override
public RFuture removeAsync(Object o) {
return removeAllAsync(Collections.singleton(o));
}
@Override
public RFuture removeAllAsync(Collection> c) {
if (c.isEmpty()) {
return new CompletableFutureWrapper<>(false);
}
return commandExecutor.evalWriteAsync(getRawName(), codec, RedisCommands.EVAL_BOOLEAN,
"local count = 0; " +
"for i = 1, #ARGV, 1 do "
+ "if redis.call('lrem', KEYS[1], 0, ARGV[i]) == 1 then "
+ "count = count + 1; "
+ "end; "
+"end; "
+ "if count > 0 then "
+ "local value = redis.call('incrby', KEYS[2], count); "
+ "redis.call('publish', KEYS[3], value); "
+ "return 1;"
+ "end;"
+ "return 0 ",
Arrays.asList(getRawName(), semaphore.getRawName(), channelName), encode(c).toArray());
}
@Override
public RFuture pollAsync() {
return commandExecutor.evalWriteNoRetryAsync(getRawName(), codec, RedisCommands.EVAL_OBJECT,
"local res = redis.call('lpop', KEYS[1]);"
+ "if res ~= false then " +
"local value = redis.call('incrby', KEYS[2], ARGV[1]); " +
"redis.call('publish', KEYS[3], value); "
+ "end;"
+ "return res;",
Arrays.asList(getRawName(), semaphore.getRawName(), channelName), 1);
}
/*
* (non-Javadoc)
* @see java.util.concurrent.BlockingQueue#take()
*/
@Override
public V take() throws InterruptedException {
return commandExecutor.getInterrupted(takeAsync());
}
@Override
public RFuture pollAsync(long timeout, TimeUnit unit) {
RFuture takeFuture = blockingQueue.pollAsync(timeout, unit);
return wrapTakeFuture(takeFuture);
}
/*
* (non-Javadoc)
* @see java.util.concurrent.BlockingQueue#poll(long, java.util.concurrent.TimeUnit)
*/
@Override
public V poll(long timeout, TimeUnit unit) throws InterruptedException {
return commandExecutor.getInterrupted(pollAsync(timeout, unit));
}
/*
* (non-Javadoc)
* @see org.redisson.core.RBlockingQueue#pollFromAny(long, java.util.concurrent.TimeUnit, java.lang.String[])
*/
@Override
public V pollFromAny(long timeout, TimeUnit unit, String... queueNames) throws InterruptedException {
return commandExecutor.getInterrupted(pollFromAnyAsync(timeout, unit, queueNames));
}
/*
* (non-Javadoc)
* @see org.redisson.core.RBlockingQueueAsync#pollFromAnyAsync(long, java.util.concurrent.TimeUnit, java.lang.String[])
*/
@Override
public RFuture pollFromAnyAsync(long timeout, TimeUnit unit, String... queueNames) {
RFuture takeFuture = blockingQueue.pollFromAnyAsync(timeout, unit, queueNames);
return wrapTakeFuture(takeFuture);
}
@Override
public Entry pollFromAnyWithName(Duration timeout, String... queueNames) throws InterruptedException {
return commandExecutor.getInterrupted(pollFromAnyWithNameAsync(timeout, queueNames));
}
@Override
public RFuture> pollFromAnyWithNameAsync(Duration timeout, String... queueNames) {
RFuture> takeFuture = blockingQueue.pollFromAnyWithNameAsync(timeout, queueNames);
return wrapTakeFuture(takeFuture);
}
@Override
public Map> pollFirstFromAny(Duration duration, int count, String... queueNames) {
return get(pollFirstFromAnyAsync(duration, count, queueNames));
}
@Override
public Map> pollLastFromAny(Duration duration, int count, String... queueNames) {
return get(pollLastFromAnyAsync(duration, count, queueNames));
}
@Override
public RFuture