lock.java

  /**
     * Creates a distributed lock implementation that provides
     * exclusive access to a shared resource.
     * <p>
     * <pre>
     *      DistributedLock<byte[]> lock = ...;
     *      if (lock.tryLock()) {
     *          try {
     *              // manipulate protected state
     *          } finally {
     *              lock.unlock();
     *          }
     *      } else {
     *          // perform alternative actions
     *      }
     * </pre>
     * <p>
     * The algorithm relies on the assumption that while there is no
     * synchronized clock across the processes, still the local time in
     * every process flows approximately at the same rate, with an error
     * which is small compared to the auto-release time of the lock.
     *
     * @param target   key of the distributed lock that acquired.
     * @param lease    the lease time for the distributed lock to live.
     * @param unit     the time unit of the {@code expire} argument.
     * @param watchdog if the watchdog is not null, it will auto keep
     *                 lease of current lock, otherwise won't keep lease,
     *                 this method dose not pay attention to the life cycle
     *                 of watchdog, please maintain it yourself.
     * @return a distributed lock instance.
     */
    DistributedLock<byte[]> getDistributedLock(final byte[] target, final long lease, final TimeUnit unit,
                                               final ScheduledExecutorService watchdog);