Zookeeper的安装及共享锁的应用

1.zookeeper的安装

1.1 下载安装包

Wget http://mirror.bit.edu.cn/apache/zookeeper/zookeeper-3.4.6/zookeeper-3.4.6.tar.gz

1.2 .解压缩安装包 tar -zxvf zookeeper-3.4.6.tar.gz 这里我们的操作都是在一个新建目录/opt/zookeeper 文件夹下完成的，自己可以根据实际需要创建文件夹

1.3 进入/opt/zookeeper/zookeeper-3.4.6/conf文件夹，将zoo_sample.cfg 文件重命名为 zoo.cfg ，命令:mv zoo_sample.cfg zoo.cfg

1.4 修改zoo.cfg配置文件命令vi zoo.cfg ,将dataDir，dataLogDar参数进行配置，文件夹可以自己定义，在这里我配置成如下：

　dataDir=/opt/zookeeper/dataAndLog

　　 dataLogDir=/opt/zookeeper/dataAndLog

1.5 进入/opt/zookeeper/zookeeper-3.4.6/bin目录，启动zookeeper,命令为: ./zkServer.sh start

1.6 查看zookeeper 运行状态 ./zkServer.sh status，或者输入ps aux|grep zookeeper ,这里我们发现zookeeper 并没有正常启动，这里我们可以输入cat zookeeper.out 来查看启动信息

这里我们发现没有安装jdk

1.7 安装jdk

通过yum 安装openjdk1.7 yum -y install java-1.7.0-openjdk* ，jdk安装完成后输入 java -version 来查看jdk安装情况

1.8 再次启动zookeeper

输入 ./zkServer.sh start 重新启动zookeeper ,然后再次通过 ./zkServer.sh status cat zookeeper.out ps aux|grep zookeeper 来查看启动状态启动完成.

1.9 配置防火墙端口

Zookeeper 需要用到3个端口 2181 ，2888 ，3888 ，第一个是客户端连接的端口，后两个是做zookeeper集群时所用的端口。

修改防火墙配置文件 vi /etc/sysconfig/iptables 加入下面内容

-A INPUT -p tcp -m tcp --dport 2181 -j ACCEPT

-A INPUT -p tcp -m tcp --dport 2888 -j ACCEPT

-A INPUT -p tcp -m tcp --dport 3888 -j ACCEPT

然后重启防火墙

/etc/init.d/iptables restart

2.0 集群的配置

在生产环境中，要配置成分布式模式，才能发挥威力。

ZooKeeper集群一般被称为ZooKeeper ensemble，或者 quorum.

准备3台机器

假设有三台机器，hostname和ip对应关系是：

192.168.1.101 hadoop101

192.168.1.102 hadoop102

192.168.1.103 hadoop103

ZooKeeper不存在明显的master/slave关系，各个节点都是服务器，leader挂了，会立马从follower中选举一个出来作为leader.

由于没有主从关系，也不用配置SSH无密码登录了，各个zk服务器是自己启动的，互相之间通过TCP端口来交换数据。

修改hadoop101的配置文件conf/zoo.cfg

....

clientPort=2181

server.1=hadoop101:2888:3888 /server.1=192.168.1.101:2888:3888

server.2=hadoop102:2888:3888/server.1=192.168.1.102:2888:3888

server.3=hadoop103:2888:3888/server.1=192.168.1.103:2888:3888

修改完后拷贝到 hadoop102,以及 hadoop103上.

然后启动每台机器，因为3个节点的启动是有顺序的，所以在陆续启动三个节点的时候，前面先启动的节点连接未启动的节点的时候会报出一些错误。可以忽略。

可以使用java客户端连接ZooKeeper集群中的任意一台服务器了。

2.分布式共享锁的应用

2.1 这里讲解一下使用java客户端来获取共享锁

这里有一个客户端类 DistributedLock.java 代码如下：

package com.daat.front.activity.web.actions.tools;
 
import java.io.IOException;
 
import java.util.ArrayList;
 
import java.util.Collections;
 
import java.util.List;
 
import java.util.concurrent.CountDownLatch;
 
import java.util.concurrent.TimeUnit;
 
import java.util.concurrent.locks.Condition;
 
import java.util.concurrent.locks.Lock;
 
import org.apache.log4j.Logger;
 
import org.apache.zookeeper.CreateMode;
 
import org.apache.zookeeper.KeeperException;
 
import org.apache.zookeeper.WatchedEvent;
 
import org.apache.zookeeper.Watcher;
 
import org.apache.zookeeper.ZooDefs;
 
import org.apache.zookeeper.ZooKeeper;
 
import org.apache.zookeeper.data.Stat;
 
import com.daat.front.activity.service.bo.impl.BoActivity;
 
/**
 
 * 基于zoopkeeper的分布式共享锁
 
 * @author yank
 
 *
 
 */
 
public class DistributedLock implements Lock, Watcher {
 
private ZooKeeper zk;
 
private String root = "/locks";
 
private String lockName;
 
private String waitNode;
 
private String myZnode;
 
private CountDownLatch latch;
 
private int sessionTimeout = ;
 
private List<Exception> exception = new ArrayList<Exception>();
 
private static Logger log = Logger.getLogger(DistributedLock.class);
 
public DistributedLock(String config, String lockName) {
 
this.lockName = lockName;
 
try {
 
zk = new ZooKeeper(config, sessionTimeout, this);
 
Stat stat = zk.exists(root, false);
 
if (stat == null) {
 
zk.create(root, new byte[], ZooDefs.Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT);
 
}
 
} catch (IOException e) {
 
e.printStackTrace();
 
exception.add(e);
 
} catch (KeeperException e) {
 
e.printStackTrace();
 
exception.add(e);
 
} catch (InterruptedException e) {
 
e.printStackTrace();
 
exception.add(e);
 
}
 
}
 
public void process(WatchedEvent event) {
 
if (this.latch != null) {
 
this.latch.countDown();
 
}
 
}
 
public void lock() {
 
if (exception.size() > ) {
 
throw new LockException(exception.get());
 
}
 
try {
 
if (this.tryLock()) {
 
System.out.println("Thread " + Thread.currentThread().getId()+ " " + myZnode + " get lock true");
 
return;
 
} else {
 
waitForLock(waitNode, sessionTimeout);
 
}
 
} catch (KeeperException e) {
 
e.printStackTrace();
 
throw new LockException(e);
 
} catch (InterruptedException e) {
 
e.printStackTrace();
 
throw new LockException(e);
 
}
 
}
 
public boolean tryLock() {
 
try {
 
String splitStr = "_lock_";
 
if (lockName.contains(splitStr))
 
throw new LockException("lockName can not contains \\u000B");
 
myZnode = zk.create(root + "/" + lockName + splitStr, new byte[],ZooDefs.Ids.OPEN_ACL_UNSAFE,CreateMode.EPHEMERAL_SEQUENTIAL);
 
System.out.println(myZnode + " is created ");
 
List<String> subNodes = zk.getChildren(root, false);
 
List<String> lockObjNodes = new ArrayList<String>();
 
for (String node : subNodes) {
 
String _node = node.split(splitStr)[];
 
if (_node.equals(lockName)) {
 
lockObjNodes.add(node);
 
}
 
}
 
Collections.sort(lockObjNodes);
 
System.out.println(myZnode + "==" + lockObjNodes.get());
 
if (myZnode.equals(root + "/" + lockObjNodes.get())) {
 
return true;
 
}
 
String subMyZnode = myZnode.substring(myZnode.lastIndexOf("/") + );
 
waitNode = lockObjNodes.get(Collections.binarySearch(lockObjNodes,subMyZnode) - );
 
} catch (KeeperException e) {
 
e.printStackTrace();
 
throw new LockException(e);
 
} catch (InterruptedException e) {
 
e.printStackTrace();
 
throw new LockException(e);
 
}
 
return false;
 
}
 
public boolean tryLock(long time, TimeUnit unit) {
 
try {
 
if (this.tryLock()) {
 
return true;
 
}
 
return waitForLock(waitNode, time);
 
} catch (Exception e) {
 
e.printStackTrace();
 
}
 
return false;
 
}
 
private boolean waitForLock(String lower, long waitTime)
 
throws InterruptedException, KeeperException {
 
Stat stat = zk.exists(root + "/" + lower, true);
 
if (stat != null) {
 
System.out.println("Thread " + Thread.currentThread().getId()+ " waiting for " + root + "/" + lower);
 
this.latch = new CountDownLatch();
 
this.latch.await(waitTime, TimeUnit.MILLISECONDS);
 
this.latch = null;
 
}
 
return true;
 
}
 
public void unlock() {
 
try {
 
System.out.println("unlock " + myZnode);
 
zk.delete(myZnode, -);
 
myZnode = null;
 
zk.close();
 
} catch (InterruptedException e) {
 
e.printStackTrace();
 
} catch (KeeperException e) {
 
e.printStackTrace();
 
}
 
}
 
public void lockInterruptibly() throws InterruptedException {
 
this.lock();
 
}
 
public Condition newCondition() {
 
return null;
 
}
 
public class LockException extends RuntimeException {
 
private static final long serialVersionUID = 1L;
 
public LockException(String e) {
 
super(e);
 
}
 
public LockException(Exception e) {
 
super(e);
 
}
 
}
 
}

2.2 再写一个测试类 TestLock.java 代码如下：

package com.daat.front.base.web.tools;
 
import java.util.Date;
 
public class TestLock  implements Runnable{
 
public static void main(String[] args) {
 
for(int i=;i<;i++){
 
Thread ad=new Thread(new TestLock());
 
ad.start();
 
}
 
}
 
@Override
 
public void run() {
 
DistributedLock lock = null;
 
try {
 
System.out.println("线程开启:"+Thread.currentThread().getId());
 
//多个锁用“，” 分隔开
 
//lock = new DistributedLock("10.168.128.113:2181,10.168.173.159:2181", "amount");
 
Thread.sleep();
 
lock = new DistributedLock("192.168.122.129:2181", "testLock");
 
lock.lock();
 
System.out.println("线程："+Thread.currentThread().getId()+"在"+new Date().getTime()+"时间获得锁");
 
Thread.sleep();
 
System.out.println("===Thread "+ Thread.currentThread().getId() + " running");
 
} catch (Exception e) {
 
e.printStackTrace();
 
}finally{
 
if (lock != null){
 
System.out.println("线程："+Thread.currentThread().getId()+"在"+new Date().getTime()+"释放锁");
 
lock.unlock();
 
}
 
}
 
}
 
}

测试类是开启10个线程同时去做锁竞争操作，看看是否可以控制

获取锁---->释放锁的操作，测试结果如下：

第一次测试：

线程开启:9

线程开启:11

线程开启:10

线程开启:12

线程开启:15

线程开启:14

线程开启:13

线程开启:16

线程开启:17

线程开启:18

线程：11在1478591252342时间获得锁

线程：11在1478591257342释放锁

线程：14在1478591257348时间获得锁

线程：14在1478591262349释放锁

线程：15在1478591262352时间获得锁

线程：15在1478591267352释放锁

线程：10在1478591267360时间获得锁

线程：10在1478591272360释放锁

线程：12在1478591272364时间获得锁

线程：12在1478591277364释放锁

线程：16在1478591277367时间获得锁

线程：16在1478591282368释放锁

线程：9在1478591282371时间获得锁

线程：9在1478591287371释放锁

线程：18在1478591285302时间获得锁

线程：18在1478591290302释放锁

线程：13在1478591285302时间获得锁

线程：13在1478591290302释放锁

线程：17在1478591285303时间获得锁

线程：17在1478591290303释放锁

第二次测试：

线程开启:9

线程开启:11

线程开启:12

线程开启:10

线程开启:13

线程开启:14

线程开启:15

线程开启:16

线程开启:18

线程开启:17

线程：17在1478591690760时间获得锁

线程：17在1478591694760释放锁

线程：18在1478591694767时间获得锁

线程：18在1478591698767释放锁

线程：14在1478591698770时间获得锁

线程：14在1478591702771释放锁

线程：15在1478591702775时间获得锁

线程：15在1478591706775释放锁

线程：12在1478591706778时间获得锁

线程：12在1478591710778释放锁

线程：11在1478591710783时间获得锁

线程：11在1478591714783释放锁

线程：9在1478591714786时间获得锁

线程：9在1478591718787释放锁

线程：10在1478591718790时间获得锁

线程：10在1478591722790释放锁

线程：16在1478591720773时间获得锁

线程：16在1478591724773释放锁

线程：13在1478591720774时间获得锁

线程：13在1478591724774释放锁

通过测试。