Java Lock类代码示例

import io.vertx.core.shareddata.Lock; //导入依赖的package包/类
/**
 * Get the record corresponding to a given component identifier
 *
 * @param id     Component identifier
 * @param future Future to provide the record
 * @see <a href="http://vertx.io/docs/apidocs/io/vertx/core/Future.html" target="_blank">Future</a>
 */
private void getClusterRecord(final String id, Future<JsonObject> future) {
	sharedData.getLock(RECORDS_LOCK_NAME, lockRes -> {
		if (lockRes.succeeded()) {
			Lock asyncLock = lockRes.result();

			clusterRecords.get(id, getRes -> {
				if (getRes.succeeded()) {
					String record = getRes.result();
					future.complete(new JsonObject(record));
				} else {
					future.fail(getRes.cause());
				}
			});

			asyncLock.release();
		} else {
			future.fail(lockRes.cause());
		}
	});
}
 

import io.vertx.core.shareddata.Lock; //导入依赖的package包/类
@Override
public void getLockWithTimeout(String name, long timeout, Handler<AsyncResult<Lock>> resultHandler) {
  vertx.executeBlocking(future -> {
    ZKLock lock = locks.get(name);
    if (lock == null) {
      InterProcessSemaphoreMutex mutexLock = new InterProcessSemaphoreMutex(curator, ZK_PATH_LOCKS + name);
      lock = new ZKLock(mutexLock);
    }
    try {
      if (lock.getLock().acquire(timeout, TimeUnit.MILLISECONDS)) {
        locks.putIfAbsent(name, lock);
        future.complete(lock);
      } else {
        future.fail(new VertxException("Timed out waiting to get lock " + name));
      }
    } catch (Exception e) {
      future.fail(new VertxException("get lock exception", e));
    }
  }, resultHandler);
}
 

import io.vertx.core.shareddata.Lock; //导入依赖的package包/类
@Override
public void getLockWithTimeout(String name, long timeout, Handler<AsyncResult<Lock>> resultHandler) {
  ContextImpl context = (ContextImpl) vertx.getOrCreateContext();
  // Ordered on the internal blocking executor
  context.executeBlocking(() -> {
    java.util.concurrent.locks.Lock lock = lockService.getLock(name);
    try {
      if (lock.tryLock(timeout, TimeUnit.MILLISECONDS)) {
        return new JGroupsLock(vertx, lock);
      } else {
        throw new VertxException("Timed out waiting to get lock " + name);
      }
    } catch (InterruptedException e) {
      Thread.currentThread().interrupt();
      throw new VertxException(e);
    }
  }, resultHandler);
}
 

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);
}
 

import io.vertx.core.shareddata.Lock; //导入依赖的package包/类
private static <T> void openCircuitBreakerAndHandleError(
    Consumer<Throwable> errorHandler,
    ThrowableErrorConsumer<Throwable, T> onFailureRespond,
    Consumer<Throwable> errorMethodHandler,
    Consumer<ExecutionResult<T>> resultConsumer,
    AsyncResult<T> event,
    Lock lock,
    Counter counter) {
  counter.addAndGet(
      LOCK_VALUE,
      val -> {
        lock.release();
        errorHandling(
            errorHandler,
            onFailureRespond,
            errorMethodHandler,
            resultConsumer,
            Future.failedFuture(event.cause()));
      });
}
 

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);
}
 

import io.vertx.core.shareddata.Lock; //导入依赖的package包/类
private static <T> void openCircuitBreakerAndHandleError(
    Future<ExecutionResult<T>> _blockingHandler,
    Consumer<Throwable> _errorHandler,
    ThrowableFunction<Throwable, T> _onFailureRespond,
    Consumer<Throwable> _errorMethodHandler,
    VxmsShared vxmsShared,
    Throwable e,
    Lock lck,
    Counter counter) {
  counter.addAndGet(
      LOCK_VALUE,
      val -> {
        lck.release();
        final Vertx vertx = vxmsShared.getVertx();
        vertx.executeBlocking(
            bhandler -> {
              T result = handleError(_errorHandler, _onFailureRespond, _errorMethodHandler, e);
              if (!_blockingHandler.isComplete()) {
                _blockingHandler.complete(new ExecutionResult<>(result, true, true, null));
              }
            },
            false,
            res -> {});
      });
}
 

import io.vertx.core.shareddata.Lock; //导入依赖的package包/类
private static <T> void openCircuitBreakerAndHandleError(
    Future<ExecutionResult<T>> _resultHandler,
    Consumer<Throwable> _errorHandler,
    ThrowableFunction<Throwable, T> _onFailureRespond,
    Consumer<Throwable> _errorMethodHandler,
    VxmsShared vxmsShared,
    Throwable e,
    Lock lck,
    Counter counter) {
  counter.addAndGet(
      LOCK_VALUE,
      val -> {
        lck.release();
        final Vertx vertx = vxmsShared.getVertx();
        vertx.executeBlocking(
            bhandler -> {
              T result = handleError(_errorHandler, _onFailureRespond, _errorMethodHandler, e);
              if (!_resultHandler.isComplete()) {
                _resultHandler.complete(new ExecutionResult<>(result, true, true, null));
              }
            },
            false,
            res -> {});
      });
}
 

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);
}
 

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);
}
 

import io.vertx.core.shareddata.Lock; //导入依赖的package包/类
@Override
public void getLockWithTimeout(String name, long timeout, Handler<AsyncResult<Lock>> handler) {
  Context context = vertx.getOrCreateContext();
  lockCache.getUnchecked(name).whenComplete((lock, error) -> {
    if (error == null) {
      lock.async().tryLock(Duration.ofMillis(timeout)).whenComplete((lockResult, lockError) -> {
        if (lockError == null) {
          if (lockResult.isPresent()) {
            context.runOnContext(v -> Future.<Lock>succeededFuture(new AtomixLock(vertx, lock)).setHandler(handler));
          } else {
            context.runOnContext(v -> Future.<Lock>failedFuture(new VertxException("Timed out waiting to get lock " + name)).setHandler(handler));
          }
        } else {
          context.runOnContext(v -> Future.<Lock>failedFuture(lockError).setHandler(handler));
        }
      });
    } else {
      context.runOnContext(v -> Future.<Lock>failedFuture(error).setHandler(handler));
    }
  });
}
 

import io.vertx.core.shareddata.Lock; //导入依赖的package包/类
@Override
public void getLockWithTimeout(String name, long timeout, Handler<AsyncResult<Lock>> resultHandler) {
  ContextImpl context = (ContextImpl) vertx.getOrCreateContext();
  // Ordered on the internal blocking executor
  context.executeBlocking(() -> {
    ISemaphore iSemaphore = hazelcast.getSemaphore(LOCK_SEMAPHORE_PREFIX + name);
    boolean locked = false;
    long remaining = timeout;
    do {
      long start = System.nanoTime();
      try {
        locked = iSemaphore.tryAcquire(remaining, TimeUnit.MILLISECONDS);
      } catch (InterruptedException e) {
        // OK continue
      }
      remaining = remaining - MILLISECONDS.convert(System.nanoTime() - start, NANOSECONDS);
    } while (!locked && remaining > 0);
    if (locked) {
      return new HazelcastLock(iSemaphore);
    } else {
      throw new VertxException("Timed out waiting to get lock " + name);
    }
  }, resultHandler);
}
 

import io.vertx.core.shareddata.Lock; //导入依赖的package包/类
@Override
public void getLockWithTimeout(final String name, final long timeout, final Handler<AsyncResult<Lock>> resultHandler) {
    AsynchronousLock lock = new AsynchronousLock(this.vertx);
    final AsynchronousLock prev = locks.putIfAbsent(name, lock);
    if (prev != null) {
        lock = prev;
    }
    final FakeLock flock = new FakeLock(lock);
    flock.acquire(timeout, resultHandler);
}
 

import io.vertx.core.shareddata.Lock; //导入依赖的package包/类
/**
 * Get the count of currently deployed components
 *
 * @param future Future to provide the count of deployed components
 * @see <a href="http://vertx.io/docs/apidocs/io/vertx/core/Future.html" target="_blank">Future</a>
 */
void count(Future<Integer> future) {
	if (!isInitialized()) {
		future.fail("DeployRecords should be initialized before using it!");
		return;
	}

	if (null == localRecords) {
		sharedData.getLock(RECORDS_LOCK_NAME, lockRes -> {
			if (lockRes.succeeded()) {
				Lock asyncLock = lockRes.result();

				clusterRecords.size(sizeRes -> {
					if (sizeRes.succeeded()) {
						future.complete(sizeRes.result());
					} else {
						future.fail(sizeRes.cause());
					}

					asyncLock.release();
				});
			} else {
				future.fail(lockRes.cause());
			}
		});

		return;
	}

	future.complete(Integer.valueOf(localRecords.size()));
}
 

import io.vertx.core.shareddata.Lock; //导入依赖的package包/类
/**
 * Method to initialize the object so that it can handle deployment and undeployment of components
 *
 * @param isClustered Whether cluster mode is opted
 * @param future      Future to provide the status of initialization
 * @see <a href="http://vertx.io/docs/apidocs/io/vertx/core/Future.html" target="_blank">Future</a>
 */
void init(Boolean isClustered, Future<Boolean> future) {
	if (isInitialized()) {
		future.complete(false);
		return;
	}

	if (isClustered) {
		sharedData.getLock(RECORDS_LOCK_NAME, lockRes -> {
			if (lockRes.succeeded()) {
				Lock asyncLock = lockRes.result();

				sharedData.<String, String>getClusterWideMap(RECORDS_MAP_NAME, mapRes -> {
					if (mapRes.succeeded()) {
						clusterRecords = mapRes.result();
						future.complete(true);
					} else {
						future.fail(mapRes.cause());
					}

					asyncLock.release();
				});
			} else {
				future.fail(lockRes.cause());
			}
		});

		return;
	}

	localRecords = sharedData.getLocalMap(RECORDS_MAP_NAME);
	future.complete(true);
}