ZooKeeper客户端curator组件介绍

Curator实现了 ZooKeeper recipes文档中列出的所有技巧(除了两段提交two phase commit)。点击下面的技巧的名字可以查看详细信息。

Elections

• Leader Latch - 在分布式计算中， leader选举是在几台节点中指派单一的进程作为任务组织者的过程。在任务开始前， 所有的网络节点都不知道哪一个节点会作为任务的leader或coordinator. 一旦leader选举算法被执行， 网络中的每个节点都将知道一个特别的唯一的节点作为任务leader.

• Leader Election - 初始的leader选举实现.

Locks

• Shared Reentrant Lock - 全功能的分布式锁。 任何一刻不会有两个client同时拥有锁.
• Shared Lock - 与Shared Reentrant Lock类似但是不是重入的.
• Shared Reentrant Read Write Lock - 类似Java的读写锁，但是是分布式的.
• Shared Semaphore - 跨JVM的计数信号量.
• Multi Shared Lock - 将多个锁看成整体，要不全部acquire成功，要不acquire全部失败。 release也是释放全部锁.

Barriers

• Barrier - 分布式的barriers。 会阻塞全部的节点的处理，直到条件满足，所有的节点会继续执行.
• Double Barrier - 双barrier 允许客户端在一个计算开始点和结束点保持同步。当足够的进程加入barrier, 进程开始它们的计算， 当所有的进程完成计算才离开.

Counters

• Shared Counter - 管理一个共享的整数integer. 所有监控同一path的客户端都会得到最新的值(ZK的 一致性保证).
• Distributed Atomic Long - 尝试原子增加的计数器首先它尝试乐观锁.如果失败，可选的InterProcessMutex会被采用. 不管是optimistic 还是 mutex, 重试机制都被用来尝试增加值.

Caches

• Path Cache - Path Cache用来监控ZNode. Whenever a child is added, updated or removed, the Path Cache will change its state to contain the current set of children, the children’s data and the children’s state. Path caches in the Curator Framework are provided by the PathChildrenCache class. Changes to the path are passed to registered PathChildrenCacheListener instances.
• Node Cache - A utility that attempts to keep the data from a node locally cached. This class will watch the node, respond to update/create/delete events, pull down the data, etc. You can register a listener that will get notified when changes occur.

Nodes

• Persistent Ephemeral Node - An ephemeral node that attempts to stay present in ZooKeeper, even through connection and session interruptions..

Queues

• Distributed Queue - 分布式的ZK队列. Items put into the queue are guaranteed to be ordered (by means of ZK’s PERSISTENTSEQUENTIAL node). If a single consumer takes items out of the queue, they will be ordered FIFO. If ordering is important, use a LeaderSelector to nominate a single consumer.
• Distributed Id Queue - A version of DistributedQueue that allows IDs to be associated with queue items. Items can then be removed from the queue if needed.
• Distributed Priority Queue - An implementation of the Distributed Priority Queue ZK recipe.
• Distributed Delay Queue - An implementation of a Distributed Delay Queue.
• Simple Distributed Queue - A drop-in replacement for the DistributedQueue that comes with the ZK distribution.

        
1
2
3
4

        
client.create().forPath("/head", new byte[0]);
client.delete().inBackground().forPath("/head");
client.create().withMode(CreateMode.EPHEMERAL_SEQUENTIAL).forPath("/head/child", new byte[0]);
client.getData().watched().inBackground().forPath("/test");

        
1

        
eventReceived() 	A background operation has completed or a watch has triggered. Examine the given event for details

        
1
2

        
stateChanged(CuratorFramework client, ConnectionState newState)
Called when there is a state change in the connection

        
1
2

        
unhandledError(String message, Throwable e)
Called when an exception is caught in a background thread, handler, etc.

        
1
2
3
4

        
CuratorFramework    client = CuratorFrameworkFactory.builder().namespace("MyApp") ... build();
...
client.create().forPath("/test", data);
// node was actually written to: "/MyApp/test"

        
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

        
/**
* Stop the client
*/
    public void     close();
    /**
* Start a transaction builder
*
* @return builder object
* @throws Exception errors
*/
    public CuratorTransaction inTransaction() throws Exception;
    /**
* Start a get data builder
*
* @return builder object
* @throws Exception errors
*/
    public TempGetDataBuilder getData() throws Exception;

         
1
2
3
4
5
6
7
8

         
EnsurePath       ensurePath = new EnsurePath(aFullPathToEnsure);
...
String           nodePath = aFullPathToEnsure + "/foo";
ensurePath.ensure(zk);   // first time syncs and creates if needed
zk.create(nodePath, ...);
...
ensurePath.ensure(zk);   // subsequent times are NOPs
zk.create(nodePath, ...);

         
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

         
RetryLoop retryLoop = client.newRetryLoop();
while ( retryLoop.shouldContinue() )
{
   try
{
       // perform your work
...
       // it's important to re\-get the ZK instance as there may have been an error and the instance was re\-created
ZooKeeper      zk = client.getZookeeper();
retryLoop.markComplete();
}
   catch ( Exception e )
{
retryLoop.takeException(e);
}
}

         
1
2
3
4
5
6
7
8
9

         
RetryLoop.callWithRetry(client, new Callable<Void>()
{
      @Override
      public Void call() throws Exception
{
          // do your work here - it will get retried if needed
          return null;
}
});