本文整理汇总了Java中io.vertx.core.shareddata.Lock.release方法的典型用法代码示例。如果您正苦于以下问题:Java Lock.release方法的具体用法?Java Lock.release怎么用?Java Lock.release使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类io.vertx.core.shareddata.Lock
的用法示例。
在下文中一共展示了Lock.release方法的12个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Java代码示例。
示例1: executeDefaultState
import io.vertx.core.shareddata.Lock; //导入方法依赖的package包/类
private static <T> void executeDefaultState(
long _timeout,
ThrowableFutureConsumer<T> _userOperation,
VxmsShared vxmsShared,
Future<T> operationResult,
Lock lock) {
lock.release();
if (_timeout > DEFAULT_LONG_VALUE) {
addTimeoutHandler(
_timeout,
vxmsShared,
(l) -> {
if (!operationResult.isComplete()) {
operationResult.fail(new TimeoutException("operation timeout"));
}
});
}
executeAndCompleate(_userOperation, operationResult);
}
示例2: executeDefaultState
import io.vertx.core.shareddata.Lock; //导入方法依赖的package包/类
private static <T, V> void executeDefaultState(
long _timeout,
ThrowableFutureBiConsumer<T, V> step,
T inputValue,
VxmsShared vxmsShared,
Future<V> operationResult,
Lock lock) {
lock.release();
if (_timeout > DEFAULT_LONG_VALUE) {
addTimeoutHandler(
_timeout,
vxmsShared,
(l) -> {
if (!operationResult.isComplete()) {
operationResult.fail(new TimeoutException("operation timeout"));
}
});
}
executeAndCompleate(step, inputValue, operationResult);
}
示例3: executeDefaultState
import io.vertx.core.shareddata.Lock; //导入方法依赖的package包/类
private static <T> void executeDefaultState(
long _timeout,
ThrowableFutureConsumer<T> _userOperation,
VxmsShared vxmsShared,
Future<T> operationResult,
Lock lock) {
lock.release();
if (_timeout > DEFAULT_LONG_VALUE) {
addTimeoutHandler(
_timeout,
vxmsShared.getVertx(),
(l) -> {
if (!operationResult.isComplete()) {
operationResult.fail(new TimeoutException("operation timeout"));
}
});
}
executeAndCompleate(_userOperation, operationResult);
}
示例4: executeDefaultState
import io.vertx.core.shareddata.Lock; //导入方法依赖的package包/类
private static <T, V> void executeDefaultState(
long _timeout,
ThrowableFutureBiConsumer<T, V> _step,
T _inputValue,
VxmsShared vxmsShared,
Future<V> operationResult,
Lock lock) {
lock.release();
if (_timeout > DEFAULT_LONG_VALUE) {
addTimeoutHandler(
_timeout,
vxmsShared.getVertx(),
(l) -> {
if (!operationResult.isComplete()) {
operationResult.fail(new TimeoutException("operation timeout"));
}
});
}
executeAndCompleate(_step, _inputValue, operationResult);
}
示例5: handleStatefulError
import io.vertx.core.shareddata.Lock; //导入方法依赖的package包/类
private static <T> void handleStatefulError(
String _methodId,
int _retry,
long _timeout,
long _circuitBreakerTimeout,
ThrowableFutureConsumer<T> _userOperation,
Consumer<Throwable> errorHandler,
ThrowableErrorConsumer<Throwable, T> onFailureRespond,
Consumer<Throwable> errorMethodHandler,
VxmsShared vxmsShared,
Consumer<ExecutionResult<T>> resultConsumer,
AsyncResult<T> event,
Lock lock,
Counter counter,
AsyncResult<Long> valHandler) {
long count = valHandler.result();
if (count <= DEFAULT_LONG_VALUE) {
setCircuitBreakerReleaseTimer(_retry, _circuitBreakerTimeout, vxmsShared, counter);
openCircuitBreakerAndHandleError(
errorHandler, onFailureRespond, errorMethodHandler, resultConsumer, event, lock, counter);
} else {
lock.release();
retry(
_methodId,
_retry,
_timeout,
_circuitBreakerTimeout,
_userOperation,
errorHandler,
onFailureRespond,
errorMethodHandler,
vxmsShared,
resultConsumer,
event);
}
}
示例6: handleStatefulError
import io.vertx.core.shareddata.Lock; //导入方法依赖的package包/类
private static <T, V> void handleStatefulError(
String _methodId,
int _retry,
long _timeout,
long _circuitBreakerTimeout,
ThrowableFutureBiConsumer<T, V> step,
T inputValue,
Consumer<Throwable> errorHandler,
ThrowableErrorConsumer<Throwable, V> onFailureRespond,
Consumer<Throwable> errorMethodHandler,
VxmsShared vxmsShared,
Consumer<ExecutionResult<V>> resultConsumer,
AsyncResult<V> event,
Lock lock,
Counter counter,
AsyncResult<Long> valHandler) {
long count = valHandler.result();
if (count <= DEFAULT_LONG_VALUE) {
setCircuitBreakerReleaseTimer(_retry, _circuitBreakerTimeout, vxmsShared, counter);
openCircuitBreakerAndHandleError(
errorHandler, onFailureRespond, errorMethodHandler, resultConsumer, event, lock, counter);
} else {
lock.release();
retry(
_methodId,
_retry,
_timeout,
_circuitBreakerTimeout,
step,
inputValue,
errorHandler,
onFailureRespond,
errorMethodHandler,
vxmsShared,
resultConsumer,
event);
}
}
示例7: handleStatefulError
import io.vertx.core.shareddata.Lock; //导入方法依赖的package包/类
private static <T> void handleStatefulError(
String methodId,
int retry,
long timeout,
long circuitBreakerTimeout,
ThrowableFutureConsumer<T> _userOperation,
Consumer<Throwable> errorHandler,
ThrowableErrorConsumer<Throwable, T> onFailureRespond,
Consumer<Throwable> errorMethodHandler,
VxmsShared vxmsShared,
Consumer<ExecutionResult<T>> resultConsumer,
AsyncResult<T> event,
Lock lock,
Counter counter,
AsyncResult<Long> valHandler) {
long count = valHandler.result();
if (count <= DEFAULT_LONG_VALUE) {
setCircuitBreakerReleaseTimer(retry, circuitBreakerTimeout, vxmsShared.getVertx(), counter);
openCircuitBreakerAndHandleError(
errorHandler, onFailureRespond, errorMethodHandler, resultConsumer, event, lock, counter);
} else {
lock.release();
retry(
methodId,
retry,
timeout,
circuitBreakerTimeout,
_userOperation,
errorHandler,
onFailureRespond,
errorMethodHandler,
vxmsShared,
resultConsumer,
event);
}
}
示例8: handleStatefulError
import io.vertx.core.shareddata.Lock; //导入方法依赖的package包/类
private static <T, V> void handleStatefulError(
String methodId,
int retry,
long timeout,
long circuitBreakerTimeout,
ThrowableFutureBiConsumer<T, V> _step,
T _inputValue,
Consumer<Throwable> errorHandler,
ThrowableErrorConsumer<Throwable, V> onFailureRespond,
Consumer<Throwable> errorMethodHandler,
VxmsShared vxmsShared,
Consumer<ExecutionResult<V>> resultConsumer,
AsyncResult<V> event,
Lock lock,
Counter counter,
AsyncResult<Long> valHandler) {
long count = valHandler.result();
if (count <= DEFAULT_LONG_VALUE) {
setCircuitBreakerReleaseTimer(retry, circuitBreakerTimeout, vxmsShared.getVertx(), counter);
openCircuitBreakerAndHandleError(
errorHandler, onFailureRespond, errorMethodHandler, resultConsumer, event, lock, counter);
} else {
lock.release();
retry(
methodId,
retry,
timeout,
circuitBreakerTimeout,
_step,
_inputValue,
errorHandler,
onFailureRespond,
errorMethodHandler,
vxmsShared,
resultConsumer,
event);
}
}
示例9: handleStatefulError
import io.vertx.core.shareddata.Lock; //导入方法依赖的package包/类
private static <T> void handleStatefulError(
String _methodId,
ThrowableSupplier<T> _supplier,
Future<ExecutionResult<T>> _blockingHandler,
Consumer<Throwable> _errorHandler,
ThrowableFunction<Throwable, T> _onFailureRespond,
Consumer<Throwable> _errorMethodHandler,
VxmsShared vxmsShared,
Throwable _t,
int _retry,
long _timeout,
long _circuitBreakerTimeout,
long _delay,
Throwable e,
Lock lck,
Counter counter,
AsyncResult<Long> valHandler) {
//////////////////////////////////////////
long count = valHandler.result();
if (count <= DEFAULT_VALUE) {
setCircuitBreakerReleaseTimer(vxmsShared, _retry, _circuitBreakerTimeout, counter);
openCircuitBreakerAndHandleError(
_blockingHandler,
_errorHandler,
_onFailureRespond,
_errorMethodHandler,
vxmsShared,
e,
lck,
counter);
} else {
lck.release();
ResponseExecution.handleError(_errorHandler, e);
handleDelay(_delay);
createResponseBlocking(
_methodId,
_supplier,
_blockingHandler,
_errorHandler,
_onFailureRespond,
_errorMethodHandler,
vxmsShared,
_t,
_retry,
_timeout,
_circuitBreakerTimeout,
_delay);
}
////////////////////////////////////////
}
示例10: handleStatefulError
import io.vertx.core.shareddata.Lock; //导入方法依赖的package包/类
private static <T, V> void handleStatefulError(
String _methodId,
ThrowableFunction<T, V> step,
T value,
Future<ExecutionResult<V>> _resultHandler,
Consumer<Throwable> _errorHandler,
ThrowableFunction<Throwable, V> _onFailureRespond,
Consumer<Throwable> _errorMethodHandler,
VxmsShared vxmsShared,
Throwable _t,
int _retry,
long _timeout,
long _circuitBreakerTimeout,
long _delay,
Throwable e,
Lock lck,
Counter counter,
AsyncResult<Long> valHandler) {
//////////////////////////////////////////
long count = valHandler.result();
if (count <= DEFAULT_VALUE) {
setCircuitBreakerReleaseTimer(vxmsShared, _retry, _circuitBreakerTimeout, counter);
openCircuitBreakerAndHandleError(
_resultHandler,
_errorHandler,
_onFailureRespond,
_errorMethodHandler,
vxmsShared,
e,
lck,
counter);
} else {
lck.release();
ResponseExecution.handleError(_errorHandler, e);
handleDelay(_delay);
createResponseBlocking(
_methodId,
step,
value,
_resultHandler,
_errorHandler,
_onFailureRespond,
_errorMethodHandler,
vxmsShared,
_t,
_retry,
_timeout,
_circuitBreakerTimeout,
_delay);
}
////////////////////////////////////////
}
示例11: handleStatefulError
import io.vertx.core.shareddata.Lock; //导入方法依赖的package包/类
private static <T> void handleStatefulError(
String _methodId,
ThrowableSupplier<T> _supplier,
Future<ExecutionResult<T>> _blockingHandler,
Consumer<Throwable> _errorHandler,
ThrowableFunction<Throwable, T> _onFailureRespond,
Consumer<Throwable> _errorMethodHandler,
VxmsShared vxmsShared,
Throwable _t,
int _retry,
long _timeout,
long _circuitBreakerTimeout,
long _delay,
Throwable e,
Lock lck,
Counter counter,
AsyncResult<Long> valHandler) {
//////////////////////////////////////////
long count = valHandler.result();
if (count <= DEFAULT_LONG_VALUE) {
setCircuitBreakerReleaseTimer(vxmsShared, _retry, _circuitBreakerTimeout, counter);
openCircuitBreakerAndHandleError(
_blockingHandler,
_errorHandler,
_onFailureRespond,
_errorMethodHandler,
vxmsShared,
e,
lck,
counter);
} else {
lck.release();
org.jacpfx.vxms.rest.response.basic.ResponseExecution.handleError(_errorHandler, e);
handleDelay(_delay);
executeRetryAndCatchAsync(
_methodId,
_supplier,
_blockingHandler,
_errorHandler,
_onFailureRespond,
_errorMethodHandler,
vxmsShared,
_t,
_retry,
_timeout,
_circuitBreakerTimeout,
_delay);
}
////////////////////////////////////////
}
示例12: handleStatefulError
import io.vertx.core.shareddata.Lock; //导入方法依赖的package包/类
private static <T, V> void handleStatefulError(
String _methodId,
ThrowableFunction<T, V> step,
T value,
Future<ExecutionResult<V>> _blockingHandler,
Consumer<Throwable> _errorHandler,
ThrowableFunction<Throwable, V> _onFailureRespond,
Consumer<Throwable> _errorMethodHandler,
VxmsShared vxmsShared,
Throwable _t,
int _retry,
long _timeout,
long _circuitBreakerTimeout,
long _delay,
Throwable e,
Lock lck,
Counter counter,
AsyncResult<Long> valHandler) {
//////////////////////////////////////////
long count = valHandler.result();
if (count <= DEFAULT_LONG_VALUE) {
setCircuitBreakerReleaseTimer(vxmsShared, _retry, _circuitBreakerTimeout, counter);
openCircuitBreakerAndHandleError(
_blockingHandler,
_errorHandler,
_onFailureRespond,
_errorMethodHandler,
vxmsShared,
e,
lck,
counter);
} else {
lck.release();
org.jacpfx.vxms.rest.response.basic.ResponseExecution.handleError(_errorHandler, e);
handleDelay(_delay);
executeRetryAndCatchAsync(
_methodId,
step,
value,
_blockingHandler,
_errorHandler,
_onFailureRespond,
_errorMethodHandler,
vxmsShared,
_t,
_retry,
_timeout,
_circuitBreakerTimeout,
_delay);
}
////////////////////////////////////////
}