分布式锁--redis和zookeeper

话不多说，直接上代码

redis：

注：没用到redis的集群模式，只是用单台redis实现了分布式锁

需要引入redisson的一些包

	<dependency>
	    <groupId>redis.clients</groupId>
	    <artifactId>jedis</artifactId>
	    <version>4.0.0</version>
	</dependency>
	<dependency>
        <groupId>org.redisson</groupId>
        <artifactId>redisson</artifactId>
        <version>3.15.3</version>
    </dependency>

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;

public class Redislock {
	
	private volatile static int a = 0;
	
	
	private static RedissonClient redissonClient = new Redislock().redissonClient();
	
	public RedissonClient redissonClient() {
		
		Config config = new Config();
		//我用自己的服务器搭建了一个redis服务
		config.useSingleServer().setAddress("redis://xxx.xxx.xxx.xxx:6379");
		System.out.println("连接上redis客户端");
		
		this.redissonClient = Redisson.create(config);
				
		return redissonClient;
		
	}
	
	public static void main(String[] args) {
		
		// 用线程池模拟分布式场景
		ExecutorService executorService = Executors.newFixedThreadPool(20);
		
		for(int i = 0 ; i < 10 ; i++) {
			
			Future future = executorService.submit(new Runnable() {
				
				@Override
				public void run() {
					// 给redis一个锁标识
					RLock lock = redissonClient.getLock("selectById::" + 10);
					try {
						System.out.println(Thread.currentThread().getName() + "->try");
						lock.lock();
						System.out.println(++a);
						System.out.println(Thread.currentThread().getName() + "->success");
						Thread.sleep(1000);
						System.out.println(Thread.currentThread().getName() + "->flush");
						lock.unlock();
					} catch (Exception e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					} finally {
			            if(lock.isLocked()){//判断锁是否处于锁定
			                if(lock.isHeldByCurrentThread()){//判断是否时该进程自己的锁
			                }
			            }
			        }
				}
			});
		}
	}
}

zookeeper：

引入依赖：

<!--下面2个依赖是zk分布式锁的，适用于并发不高的场景，适用于100以内-->
  		<dependency>
			<groupId>org.apache.curator</groupId>
			<artifactId>curator-framework</artifactId>
			<version>4.0.0</version>
		</dependency>
		
		<dependency>
			<groupId>org.apache.curator</groupId>
			<artifactId>curator-recipes</artifactId>
			<version>4.0.0</version>
		</dependency>

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.locks.InterProcessMutex;
import org.apache.curator.retry.ExponentialBackoffRetry;

public class ZKLock {
	
	private volatile static int i = 0;
	

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		
		ExecutorService executorService = Executors.newFixedThreadPool(20);
		
		CuratorFramework curatorFramework = CuratorFrameworkFactory
				.newClient("120.48.29.83:2181", 5000,4000,new ExponentialBackoffRetry(1000, 1));
			
		curatorFramework.start();
			
		InterProcessMutex lock = new InterProcessMutex(curatorFramework, "/locks");
		long a = System.currentTimeMillis();
		System.out.println(a);
		for(int i = 0 ; i < 100 ; i++) {
			
			Future future = executorService.submit(new Runnable() {
				
				@Override
				public void run() {
					System.out.println(Thread.currentThread().getName() + "->try");
					try {
						lock.acquire();//抢占锁
						System.out.println(Thread.currentThread().getName() + "->success");
						
						Thread.sleep(20);
						lock.release();//当前获得锁的线程在2之后释放
						System.out.println(Thread.currentThread().getName() + "->flush");
					} catch (Exception e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					System.out.println(++ZKLock.i);
				}
			});
			
		}
	}
}