分布式锁是一种在分布式系统中用于控制多个节点对共享资源访问的机制。它能确保在同一时间只有一个节点可以获得锁，从而访问共享资源，避免多个节点同时修改数据导致的混乱局面。以下是几种常见的分布式锁实现方式及其使用示例：
1. 基于数据库的分布式锁
使用数据库的行锁或唯一索引来实现。虽然简单，但性能可能不太理想。
2. 基于Redis的分布式锁
使用Redis的`SETNX`命令来实现。以下是一个简单的Python示例，使用`aioredis`库：
```python
import asyncio
import aioredis
class AsyncRedisLock:
def __init__(self, redis_conn, lock_key, expire_seconds=10):
self.redis = redis_conn
self.lock_key = lock_key
self.expire_seconds = expire_seconds
async def acquire(self):
locked = await self.redis.setnx(self.lock_key, "1")
if locked:
await self.redis.expire(self.lock_key, self.expire_seconds)
return locked
async def release(self):
await self.redis.delete(self.lock_key)
使用示例
async def main():
redis_conn = await aioredis.create_redis_pool('redis://localhost')
lock = AsyncRedisLock(redis_conn, 'myLock')
if await lock.acquire():
try:
print("获得锁,执行操作")
做一些需要加锁的操作
finally:
await lock.release()
else:
print("没有获得锁,跳过操作")
asyncio.run(main())
```
3. 基于Zookeeper的分布式锁
使用Zookeeper创建临时序列节点来实现。以下是一个简单的Java示例，使用`CuratorFramework`库：
```java
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 ZookeeperLockExample {
public static void main(String[] args) throws Exception {
CuratorFramework client = CuratorFrameworkFactory.builder()
.connectString("localhost:2181")
.retryPolicy(new ExponentialBackoffRetry(1000, 3))
.build();
client.start();
InterProcessMutex lock = new InterProcessMutex(client, "/Lock");
try {
if (lock.acquire(0, TimeUnit.SECONDS)) {
try {
// 做一些需要加锁的操作
System.out.println("获得锁,执行操作");
} finally {
lock.release();
}
} else {
System.out.println("没有获得锁,跳过操作");
}
} finally {
client.close();
}
}
}
```
4. 基于注解的Redis锁
使用Spring Data Redis提供的`StringRedisTemplate`来实现。以下是一个简单的Java示例：
```java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
@Service
public class DistributedLockService {
@Autowired
private StringRedisTemplate redisTemplate;
public void doSomething() {
String lockKey = "myLock";
Boolean locked = redisTemplate.opsForValue().setIfAbsent(lockKey, "1");
if (locked != null && locked) {
try {
// 做一些需要加锁的操作
System.out.println("获得锁,执行操作");
} finally {
redisTemplate.delete(lockKey);
}
} else {
System.out.println("没有获得锁,跳过操作");
}
}
}
```
总结
选择合适的分布式锁实现方式需要根据具体的应用场景和需求来决定。Redis和Zookeeper是两种常用的实现方式，各有优缺点。Redis实现简单且性能较高，而Zookeeper提供了更强大的顺序和监控机制。根据具体需求选择合适的实现方式，可以确保分布式系统中的数据一致性和并发控制。