1.基本介紹
分佈式鎖是控制分佈式系統之間同步訪問共享資源的一種方式,需要互斥來防止彼此干擾來保證一致性。利用Zookeeper的強一致性可以完成鎖服務。Zookeeper的官方文檔是列舉了兩種鎖,獨佔鎖和共享鎖。獨佔鎖保證任何時候都只有一個進程能或者資源的讀寫權限。共享鎖可以同時有多個讀,但是同一時刻最多只能有一個寫,讀和寫是互斥的。
2.場景分析
我們準備來實現互斥的鎖,按照官網的思路,給定一個鎖的路徑,如/Lock,所有要申請這個鎖的進程都在/Lock目錄下創建一個/Lock/lock-的臨時序列節點,並監控/Lock的子節點變化事件。當子節點發送變化時用get_children()獲取子節點的列表,如果發現進程發現自己擁有最小的一個序號,則獲得鎖。處理業務完畢後需要釋放鎖,此時只需要刪除該臨時節點即可。簡單來說就是永遠是擁有最小序號的進程獲得鎖。
3.場景實踐
使用鎖有兩個基本的函數,就是lock
或unlock
.定義爲
Lock *lock(zhandle_t *zkhandle,const char *path)
lock函數有兩個參數,一個是zookeeper_init返回的句柄zkhandle,另一個是鎖的路徑,如果成功則返回一個Lock的結構體指針,並同時獲得鎖,否則返回NULL。int unlock(zhandle_t *zkhandle,Lock * *lock)
unlock函數也有兩個參數,一個是zookeeper_init返回的句柄zkhandle,另一個是lock函數返回的結構體指針的指針。
接下來在看具體的實現。
Lock *lock(zhandle_t *zkhandle,const char *path)
{
Lock *lock = create_lock(zkhandle,path);
if(lock != NULL){
while(try_lock(zkhandle,lock) == 0){
sleep(1);
}
}else{
fprintf(stderr,"error when create lock %s.\n",path);
}
return lock;
}
create_lock
:負責鎖的初始化,主要功能是負責創建{path}的節點已經{path}/lock-的臨時序列節點。{path}如果存在則不再創建。try_lock
:嘗試加鎖,這個函數不會等待,失敗和成功都立即返回。其主要功能是獲取{path}的子節點列表,並查看自己是否是擁有最小序列號的節點,如果是則返回1,否則返回0;
lock
函數初始化鎖後,會持續的嘗試加鎖,直到成功。雖然我是這樣實現的,但是過於簡單粗暴(哈哈)。如果拿不到鎖的話,持續就會阻塞在lock
函數。
int unlock(zhandle_t *zkhandle,Lock * *lock)
{
if(*lock){
int ret = zoo_delete(zkhandle,(*lock)->selfpath,-1);
if(ret != ZOK){
fprintf(stderr,"error when release lock %s.\n",(*lock)->selfpath);
}
free(*lock);
*lock = NULL;
return ret;
}
return ZOK;
}
unlock
函數就非常簡單了,就是將create_lock
中創建的臨時序列節點刪除就可以了。
接下來在看下模擬程序的功能。
> ./mylock -h
Usage : [mylock] [-h] [-p path][-s ip:port]
-h Show help
-p lock path
-s zookeeper server ip:port
For example:
mylock -s 172.17.0.36:2181 -p /Lock
模擬程序有3個選項。其中-s
:爲Zookeeper的服務器的ip:port.-p
: 爲鎖的路徑。
分別同時運行多個mylock程序,就可以看到各個程序之間是如何獲取鎖的了。
最後是完整的代碼:
#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include"zookeeper.h"
#include"zookeeper_log.h"
char g_host[512]= "172.17.0.36:2181";
char g_path[512]= "/Lock";
typedef struct Lock
{
char lockpath[1024];
char selfpath[1024];
}Lock;
void print_usage();
void get_option(int argc,const char* argv[]);
/**********unitl*********************/
void print_usage()
{
printf("Usage : [mylock] [-h] [-p path][-s ip:port] \n");
printf(" -h Show help\n");
printf(" -p lock path\n");
printf(" -s zookeeper server ip:port\n");
printf("For example:\n");
printf(" mylock -s172.17.0.36:2181 -p /Lock\n");
}
void get_option(int argc,const char* argv[])
{
extern char *optarg;
int optch;
int dem = 1;
const char optstring[] = "hp:s:";
while((optch = getopt(argc , (char * const *)argv , optstring)) != -1 )
{
switch( optch )
{
case 'h':
print_usage();
exit(-1);
case '?':
print_usage();
printf("unknown parameter: %c\n", optopt);
exit(-1);
case ':':
print_usage();
printf("need parameter: %c\n", optopt);
exit(-1);
case 's':
strncpy(g_host,optarg,sizeof(g_host));
break;
case 'p':
strncpy(g_path,optarg,sizeof(g_path));
break;
default:
break;
}
}
}
Lock *create_lock(zhandle_t *zkhandle,const char *path)
{
char path_buffer[512]={0};
int bufferlen = sizeof(path_buffer);
Lock * lock = NULL;
int ret = zoo_exists(zkhandle,path,0,NULL);
if(ret != ZOK){
ret = zoo_create(zkhandle,path,"1.0",strlen("1.0"),
&ZOO_OPEN_ACL_UNSAFE,0,
path_buffer,bufferlen);
if(ret != ZOK){
fprintf(stderr,"failed to create the path %s!\n",path);
}else{
printf("create path %s successfully!\n",path);
}
}
if(ret == ZOK){
char child_path[512];
sprintf(child_path,"%s/lock-",path);
ret = zoo_create(zkhandle,child_path,"1.0",strlen("1.0"),
&ZOO_OPEN_ACL_UNSAFE,ZOO_SEQUENCE|ZOO_EPHEMERAL,
path_buffer,bufferlen);
if(ret != ZOK){
fprintf(stderr,"failed to create the path %s!\n",path);
}else{
printf("create path %s successfully!\n",path);
}
}
if(ret == ZOK){
lock = (Lock *)malloc(sizeof(Lock));
strcpy(lock->lockpath,path);
strcpy(lock->selfpath,path_buffer);
}
return lock;
}
int try_lock(zhandle_t *zkhandle,Lock *lock)
{
struct String_vector children;
int i = 0;
int ret = zoo_get_children(zkhandle,lock->lockpath,0,&children);
if(ret != ZOK){
fprintf(stderr,"error when get children of path %s\n",lock->lockpath);
ret = -1;
}else{
char *myseq = rindex(lock->selfpath,'/');
if (myseq != NULL) myseq += 1;
ret = 1;
for(i = 0; i < children.count; ++i){
if(strcmp(children.data[i],myseq) < 0){
ret = 0;
break;
}
}
for(i = 0; i < children.count; ++i){
free(children.data[i]);
children.data[i] = NULL;
}
}
return ret;
}
Lock *lock(zhandle_t *zkhandle,const char *path)
{
Lock *lock = create_lock(zkhandle,path);
if(lock != NULL){
while(try_lock(zkhandle,lock) == 0){
sleep(1);
}
}else{
fprintf(stderr,"error when create lock %s.\n",path);
}
return lock;
}
int unlock(zhandle_t *zkhandle,Lock * *lock)
{
if(*lock){
int ret = zoo_delete(zkhandle,(*lock)->selfpath,-1);
if(ret != ZOK){
fprintf(stderr,"error when release lock %s.\n",(*lock)->selfpath);
}
free(*lock);
*lock = NULL;
return ret;
}
return ZOK;
}
int main(int argc, const char *argv[])
{
int timeout = 30000;
char path_buffer[512];
int bufferlen=sizeof(path_buffer);
zoo_set_debug_level(ZOO_LOG_LEVEL_WARN); //設置日誌級別,避免出現一些其他信息
get_option(argc,argv);
zhandle_t* zkhandle = zookeeper_init(g_host,NULL, timeout, 0, (char *)"lock Test", 0);
if (zkhandle ==NULL)
{
fprintf(stderr, "Error when connecting to zookeeper servers...\n");
exit(EXIT_FAILURE);
}
int ret = zoo_exists(zkhandle,g_path,0,NULL);
if(ret != ZOK){
ret = zoo_create(zkhandle,g_path,"1.0",strlen("1.0"),
&ZOO_OPEN_ACL_UNSAFE,0,
path_buffer,bufferlen);
if(ret != ZOK){
fprintf(stderr,"failed to create the path %s!\n",g_path);
}else{
printf("create path %s successfully!\n",g_path);
}
}
if(ret == ZOK ){
Lock *mylock = lock(zkhandle,g_path);
if(mylock){
printf("get lock of %s.\n",g_path);
printf("self path is %s.\n",mylock->selfpath);
printf("do something....\n");
getchar();
unlock(zkhandle,&mylock);
}
}
zookeeper_close(zkhandle);
return 0;
}