Java ThrowableConsumer类代码示例

import com.github.phantomthief.util.ThrowableConsumer; //导入依赖的package包/类
public V unregister(K key, ThrowableConsumer<V, Throwable> cleanup) {
    synchronized (lock) {
        AtomicInteger counter = counters.get(key);
        if (counter == null) {
            throw new IllegalStateException("non paired unregister call for key:" + key);
        }
        int count = counter.decrementAndGet();

        if (count < 0) { // impossible run into here
            throw new IllegalStateException("INVALID INTERNAL STATE:" + key);
        } else if (count > 0) { // wait others to unregister
            return resources.get(key);
        } else { // count == 0
            V removed = resources.remove(key);
            counters.remove(key);
            try {
                cleanup.accept(removed);
                logger.info("cleanup resource:{}->{}", key, removed);
            } catch (Throwable e) {
                throwIfUnchecked(e);
                throw new RuntimeException(e);
            }
            return removed;
        }
    }
}
 

import com.github.phantomthief.util.ThrowableConsumer; //导入依赖的package包/类
SimpleBufferTrigger(Supplier<Object> bufferFactory, ToIntBiFunction<Object, E> queueAdder,
        ScheduledExecutorService scheduledExecutorService,
        ThrowableConsumer<Object, Throwable> consumer,
        TriggerStrategy triggerStrategy, BiConsumer<Throwable, Object> exceptionHandler,
        long maxBufferCount, Consumer<E> rejectHandler) {
    this.queueAdder = queueAdder;
    this.bufferFactory = bufferFactory;
    this.consumer = consumer;
    this.exceptionHandler = exceptionHandler;
    this.maxBufferCount = maxBufferCount;
    this.rejectHandler = rejectHandler;
    this.buffer.set(this.bufferFactory.get());
    ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    readLock = lock.readLock();
    writeLock = lock.writeLock();
    scheduledExecutorService.schedule(
            new TriggerRunnable(scheduledExecutorService, triggerStrategy),
            DEFAULT_NEXT_TRIGGER_PERIOD, MILLISECONDS);
}
 

import com.github.phantomthief.util.ThrowableConsumer; //导入依赖的package包/类
private ZkBasedNodeResource(Builder<T> builder) {
    this.factory = builder.factory;
    this.refreshFactory = builder.refreshFactory;
    this.cleanup = builder.cleanup;
    this.waitStopPeriod = builder.waitStopPeriod;
    this.emptyObject = builder.emptyObject;
    this.onResourceChange = builder.onResourceChange;
    this.nodeCacheShutdown = builder.nodeCacheShutdown;
    this.nodeCache = lazy(builder.cacheFactory);
    this.factoryFailedListener = t -> {
        for (ThrowableConsumer<Throwable, ?> failedListener : builder.factoryFailedListeners) {
            try {
                failedListener.accept(t);
            } catch (Throwable e) {
                logger.error("", e);
            }
        }
    };
}
 

import com.github.phantomthief.util.ThrowableConsumer; //导入依赖的package包/类
public static <T, X extends Throwable> void runWithRetry(int maxRetryTimes,
        long sleepBetweenRetryMs, Failover<T> failover, ThrowableConsumer<T, X> func) throws X {
    supplyWithRetry(maxRetryTimes, sleepBetweenRetryMs, failover, t -> {
        func.accept(t);
        return null;
    }, alwaysTrue());
}
 

import com.github.phantomthief.util.ThrowableConsumer; //导入依赖的package包/类
public static <T, X extends Throwable> void run(Failover<T> failover,
        ThrowableConsumer<T, X> func, Predicate<Throwable> failChecker) throws X {
    supply(failover, t -> {
        func.accept(t);
        return null;
    }, failChecker);
}
 

import com.github.phantomthief.util.ThrowableConsumer; //导入依赖的package包/类
public <X extends Throwable> void run(Collection<T> candidates,
        ThrowableConsumer<T, X> function) throws X {
    supply(candidates, t -> {
        function.accept(t);
        return null;
    });
}
 

import com.github.phantomthief.util.ThrowableConsumer; //导入依赖的package包/类
BatchConsumeBlockingQueueTrigger(long lingerMs, int batchSize, int bufferSize,
        BiConsumer<Throwable, List<E>> exceptionHandler,
        ThrowableConsumer<List<E>, Exception> consumer,
        ScheduledExecutorService scheduledExecutorService) {
    this.lingerMs = lingerMs;
    this.batchSize = batchSize;
    this.queue = new LinkedBlockingQueue<>(max(bufferSize, batchSize));
    this.consumer = consumer;
    this.exceptionHandler = exceptionHandler;
    this.scheduledExecutorService = scheduledExecutorService;
    this.scheduledExecutorService.schedule(new BatchConsumerRunnable(), this.lingerMs,
            MILLISECONDS);
}
 

import com.github.phantomthief.util.ThrowableConsumer; //导入依赖的package包/类
public <E1> BufferTrigger<E1> build() {
    return new LazyBufferTrigger<>(() -> {
        ensure();
        return new SimpleBufferTrigger<>((Supplier<Object>) bufferFactory,
                (ToIntBiFunction<Object, E1>) queueAdder, scheduledExecutorService,
                (ThrowableConsumer<Object, Throwable>) consumer, triggerStrategy,
                (BiConsumer<Throwable, Object>) exceptionHandler, maxBufferCount,
                (Consumer<E1>) rejectHandler);
    });
}
 

import com.github.phantomthief.util.ThrowableConsumer; //导入依赖的package包/类
@CheckReturnValue
public <E1> Builder<E1>
        withCleanupConsumer(ThrowableConsumer<? super E1, Throwable> cleanup) {
    Builder<E1> thisBuilder = (Builder<E1>) this;
    thisBuilder.cleanup = t -> {
        try {
            cleanup.accept(t);
            return true;
        } catch (Throwable e) {
            logger.error("Ops. fail to close, path:{}", t, e);
            return false;
        }
    };
    return thisBuilder;
}
 

import com.github.phantomthief.util.ThrowableConsumer; //导入依赖的package包/类
/**
 * @see FailoverUtils#runWithRetry
 */
default <X extends Throwable> void runWithRetry(ThrowableConsumer<T, X> func) throws X {
    FailoverUtils.runWithRetry(getAll().size(), 0, this, func);
}
 

import com.github.phantomthief.util.ThrowableConsumer; //导入依赖的package包/类
public GenericBatchConsumerTriggerBuilder<E>
        setConsumerEx(ThrowableConsumer<? super List<E>, Exception> consumer) {
    builder.setConsumerEx(consumer);
    return this;
}
 

import com.github.phantomthief.util.ThrowableConsumer; //导入依赖的package包/类
public <E1> BatchConsumerTriggerBuilder<E1>
        setConsumerEx(ThrowableConsumer<? super List<E1>, Exception> consumer) {
    BatchConsumerTriggerBuilder<E1> thisBuilder = (BatchConsumerTriggerBuilder<E1>) this;
    thisBuilder.consumer = consumer::accept;
    return thisBuilder;
}
 

import com.github.phantomthief.util.ThrowableConsumer; //导入依赖的package包/类
@CheckReturnValue
public GenericZkBasedNodeBuilder<T>
        addFactoryFailedListener(@Nonnull ThrowableConsumer<Throwable, Throwable> listener) {
    builder.addFactoryFailedListener(listener);
    return this;
}
 

import com.github.phantomthief.util.ThrowableConsumer; //导入依赖的package包/类
@CheckReturnValue
public GenericZkBasedNodeBuilder<T>
        withCleanupConsumer(ThrowableConsumer<? super T, Throwable> cleanup) {
    builder.withCleanupConsumer(cleanup);
    return this;
}
 

import com.github.phantomthief.util.ThrowableConsumer; //导入依赖的package包/类
@CheckReturnValue
public <E1> Builder<E1> addFactoryFailedListener(
        @Nonnull ThrowableConsumer<Throwable, Throwable> listener) {
    factoryFailedListeners.add(checkNotNull(listener));
    return (Builder<E1>) this;
}