org.apache.curator.framework.recipes.atomic.DistributedAtomicLong Java Examples

@Override
public void startQuery() throws Exception {
    // increment the zookeeper query file
    clientLock.lock();
    try {
        DistributedAtomicLong atomicLong = getLong();
        AtomicValue<Long> longValue = atomicLong.increment();
        if (!longValue.succeeded()) {
            throw new ZookeeperLockException("Unable to start query");
        }
        if (log.isTraceEnabled()) {
            long preValue = longValue.preValue();
            long postValue = longValue.postValue();
            log.trace("Updated value for " + getQueryFile() + " from " + preValue + " to " + postValue);
        }
    } finally {
        clientLock.unlock();
    }
}
 

public void stopQuery() throws Exception {
    // decrement the zookeeper query file and delete if 0
    clientLock.lock();
    try {
        DistributedAtomicLong atomicLong = getLong();
        AtomicValue<Long> longValue = atomicLong.decrement();
        if (!longValue.succeeded()) {
            throw new ZookeeperLockException("Unable to stop query");
        }
        long postValue = longValue.postValue();
        if (log.isTraceEnabled()) {
            long preValue = longValue.preValue();
            log.trace("Updated value for " + getQueryFile() + " from " + preValue + " to " + postValue);
        }
        if (postValue == 0) {
            client.delete().forPath(getQueryFile());
        }
    } finally {
        clientLock.unlock();
    }
}
 

@Override
public boolean isQueryRunning() {
    // check existence of the query file
    clientLock.lock();
    try {
        DistributedAtomicLong atomicLong = getLong();
        AtomicValue<Long> longValue = atomicLong.get();
        if (!longValue.succeeded()) {
            throw new ZookeeperLockException("Unable to get query lock count");
        }
        long postValue = longValue.postValue();
        if (log.isTraceEnabled()) {
            log.trace("Got value for " + getQueryFile() + " to be " + postValue);
        }
        return postValue > 0;
    } catch (Exception e) {
        log.error("Unable to determine if zookeeper lock exists", e);
        // assume the query is still running for now
        return true;
    } finally {
        clientLock.unlock();
    }
}
 

/**
 * 获得ZK中的当前值,如果不存在，抛出异常
 *
 * @param path
 * @return
 * @throws Exception
 */
private long currentValueFromZk(String path) throws Exception {
    if (isExists(path)) {
        DistributedAtomicLong count = new DistributedAtomicLong(client, path, new RetryNTimes(10, 1000));
        AtomicValue<Long> val = count.get();
        return val.postValue();
    } else {
        throw new RuntimeException("Path is not existed! Call nextValue firstly!");
    }
}
 

/**
 * 获得分布式自增变量
 *
 * @param path
 * @return
 * @throws Exception
 */
public Long getIncrementValue(String path) throws Exception {
    DistributedAtomicLong atomicId = new DistributedAtomicLong(client, path, new RetryNTimes(32, 1000));
    AtomicValue<Long> rc = atomicId.get();
    if (rc.succeeded()) {
        logger.debug("getIncrementValue({}) success! get: {}.", path, rc.postValue());
    } else {
        logger.warn("getIncrementValue({}) failed! get: {}.", path, rc.postValue());
    }
    return rc.postValue();
}
 

/**
 * 自增并获得，自增后的变量
 *
 * @param path
 * @return
 * @throws Exception
 */
public Long incrementAndGetValue(String path) throws Exception {
    DistributedAtomicLong atomicId = new DistributedAtomicLong(client, path, new RetryNTimes(32, 1000));
    AtomicValue<Long> rc = atomicId.increment();
    if (rc.succeeded()) {
        logger.info("incrementAndGetValue({}) success! before: {}, after: {}.", path, rc.preValue(), rc.postValue());
    } else {
        logger.warn("incrementAndGetValue({}) failed! before: {}, after: {}.", path, rc.preValue(), rc.postValue());
    }
    return rc.postValue();
}
 

@Inject
public ZKTimestampStorage(CuratorFramework zkClient) throws Exception {
    LOG.info("ZK Client state {}", zkClient.getState());
    timestamp = new DistributedAtomicLong(zkClient, TIMESTAMP_ZNODE, new RetryNTimes(3, 1000)); // TODO Configure
    // this?
    if (timestamp.initialize(INITIAL_MAX_TS_VALUE)) {
        LOG.info("Timestamp value in ZNode initialized to {}", INITIAL_MAX_TS_VALUE);
    }
}
 

@Override
public DistributedAtomicLong createAtomicCounter(String path) {
    MockAtomicCounter counter = atomicCounters.get(path);
    if (counter == null) {
        counter = new MockAtomicCounter(path);
        atomicCounters.put(path, counter);
    }
    return counter;
}
 

@Test
public void testCounter() throws Exception {
    DistributedAtomicLong counter = new MockCurator().createAtomicCounter("/mycounter");
    counter.initialize(4l);
    assertEquals(4l, counter.get().postValue().longValue());
    assertEquals(5l, counter.increment().postValue().longValue());
}
 

public static void main(String[] args) throws IOException, Exception {
	try (TestingServer server = new TestingServer()) {
		CuratorFramework client = CuratorFrameworkFactory.newClient(server.getConnectString(), new ExponentialBackoffRetry(1000, 3));
		client.start();

		List<DistributedAtomicLong> examples = Lists.newArrayList();
		ExecutorService service = Executors.newFixedThreadPool(QTY);
		for (int i = 0; i < QTY; ++i) {
			final DistributedAtomicLong count = new DistributedAtomicLong(client, PATH, new RetryNTimes(10, 10));
			
			examples.add(count);
			Callable<Void> task = new Callable<Void>() {
				@Override
				public Void call() throws Exception {
					try {
						//Thread.sleep(rand.nextInt(1000));
						AtomicValue<Long> value = count.increment();
						//AtomicValue<Long> value = count.decrement();
						//AtomicValue<Long> value = count.add((long)rand.nextInt(20));
						System.out.println("succeed: " + value.succeeded());
						if (value.succeeded())
							System.out.println("Increment: from " + value.preValue() + " to " + value.postValue());
					} catch (Exception e) {
						e.printStackTrace();
					}

					return null;
				}
			};
			service.submit(task);
		}

		service.shutdown();
		service.awaitTermination(10, TimeUnit.MINUTES);
	}

}
 

private static Long createID(CuratorFramework curator) {
  try {
    DistributedAtomicLong counter = new DistributedAtomicLong(curator,
        ZookeeperPath.TRANSACTOR_COUNT, new ExponentialBackoffRetry(1000, 10));
    AtomicValue<Long> nextId = counter.increment();
    while (nextId.succeeded() == false) {
      nextId = counter.increment();
    }
    return nextId.postValue();
  } catch (Exception e) {
    throw new IllegalStateException(e);
  }
}
 

private DistributedAtomicLong getLong() {
    getClient();
    return atomicLong;
}
 

/** Returns an atomic counter in this, or empty if no such counter is created */
public Optional<DistributedAtomicLong> counter(String path) {
    return Optional.ofNullable(atomicCounters.get(path));
}
 

/** For internal use; prefer creating a {@link CuratorCounter} */
public DistributedAtomicLong createAtomicCounter(String path) {
    return new DistributedAtomicLong(curatorFramework, path, new ExponentialBackoffRetry((int) BASE_SLEEP_TIME.toMillis(), MAX_RETRIES));
}