分布式锁之数据库实现
分布式锁之数据库实现
什么是分布式锁
在单实例单进程的系统中，当有多个线程同时修改某个共享变量时，为了保证线程安全，就需要对变量或者代码做同步处理，这种同步操作在java中可以使用synchronized、JUC包下的显式锁、cas+volatile来实现。
而目前大部分系统都是分布式部署的，使用synchronized等手动只能保证单个进程内的线程安全，多个进程多个实例下的线程安全就需要分布式锁来实现。
目前主流的分布式锁解决方案有四种：
- 基于数据库实现（悲观+乐观）
- 基于Redis实现
- 基于ZooKeeper实现
- 基于Etcd实现
数据库之悲观锁实现分布式锁
建表sql：
CREATE TABLE `t_order` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`amount` int(11) NOT NULL,
`status` int(11) NOT NULL,
`version` int(11) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8
INSERT INTO `t_order` (`amount`, `status`, `version`) VALUES ('100', '1', '1');
先借助sql来模拟分布锁的实现：
| 步骤 | SessionA | SessionB |
|---|---|---|
| 1 | begin; | begin; |
| 2 | select * from t_order where id=1 for update; | |
| 3 | select * from t_order where id=1 for update; – 阻塞 | |
| 4 | update t_order set status=2 where id=1 and status=1; | |
| 5 | commit; | 返回查询结果 |
| 6 | update t_order set status=2 where id=1 and status=1; – 状态变了未更新成功 | |
| 7 | commit; |
说明：
- 客户端A和客户端B同时执行前面两行sql，客户端A返回数据，而客户端B阻塞等待获取行锁。
- 客户端A执行后面两行sql，提交事务，客户端B获得行锁，立刻返回数据。
- 客户端B执行后面两行sql，提交事务，释放行锁。
注意
for update语句一定要走主键索引，否则没走索引会锁住整个表，走了其他索引会产生间隙锁，可能会锁住多条记录。
Java代码实现：
package com.morris.distribute.lock.database.exclusive;
import com.morris.distribute.entity.Order;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.concurrent.TimeUnit;
@Service
@Slf4j
public class OrderService {
@Autowired
private JdbcTemplate jdbcTemplate;
/**
* 数据库分布式锁之悲观锁
*
* @param id
*/
@Transactional
public void updateStatus(int id) {
log.info("updateStatus begin, {}", id);
Integer status = jdbcTemplate.queryForObject("select status from t_order where id=? for update", new Object[]{
id}, Integer.class);
if (Order.ORDER_STATUS_NOT_PAY == status) {
try {
// 模拟耗时操作
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
int update = jdbcTemplate.update("update t_order set status=? where id=? and status=1", new Object[]{
2, id, Order.ORDER_STATUS_NOT_PAY});
if (update > 0) {
log.info("updateStatus success, {}", id);
} else {
log.info("updateStatus failed, {}", id);
}
} else {
log.info("updateStatus status already updated, ignore this request, {}", id);
}
log.info("updateStatus end, {}", id);
}
}
注意开启事务@Transactional。
使用多个线程模拟竞争锁：
package com.morris.distribute.lock.database.exclusive;
import com.morris.distribute.config.JdbcConfig;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.stream.IntStream;
public class Demo {
public static void main(String[] args) {
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
applicationContext.register(JdbcConfig.class);
applicationContext.register(OrderService.class);
applicationContext.refresh();
CyclicBarrier cyclicBarrier = new CyclicBarrier(3);
IntStream.rangeClosed(1, 3).forEach((i) -> new Thread(() -> {
OrderService orderService = applicationContext.getBean(OrderService.class);
try {
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
orderService.updateStatus(1);
}, "t" + i).start());
}
}
运行结果如下：
2020-09-16 14:16:53,248 INFO [t2] (OrderService.java:26) - updateStatus begin, 1
2020-09-16 14:16:53,248 INFO [t1] (OrderService.java:26) - updateStatus begin, 1
2020-09-16 14:16:53,248 INFO [t3] (OrderService.java:26) - updateStatus begin, 1
2020-09-16 14:16:56,289 INFO [t2] (OrderService.java:42) - updateStatus success, 1
2020-09-16 14:16:56,289 INFO [t2] (OrderService.java:49) - updateStatus end, 1
2020-09-16 14:16:56,290 INFO [t3] (OrderService.java:47) - updateStatus status already updated, ignore this request, 1
2020-09-16 14:16:56,290 INFO [t3] (OrderService.java:49) - updateStatus end, 1
2020-09-16 14:16:56,291 INFO [t1] (OrderService.java:47) - updateStatus status already updated, ignore this request, 1
2020-09-16 14:16:56,291 INFO [t1] (OrderService.java:49) - updateStatus end, 1
从运行结果可以看出，同一时间只有一个线程持有了锁。
数据库之乐观锁实现分布式锁
乐观锁每次通过版本号来判断记录是否被更新过。
package com.morris.distribute.lock.database.share;
import com.morris.distribute.entity.Order;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;
@Service
@Slf4j
public class OrderService {
@Autowired
private JdbcTemplate jdbcTemplate;
/**
* 数据库分布式锁之乐观锁
*
* @param id
*/
public void updateStatus(int id) {
log.info("updateStatus begin, {}", id);
for (;;) {
// 自旋，有可能对订单做其他操作，导致version变了，所以需要自旋
Order order = jdbcTemplate.queryForObject("select status, version from t_order where id=?",
new Object[]{
id}, (rs, row) -> {
Order o = new Order();
o.setStatus(rs.getInt(1));
o.setVersion(rs.getInt(2));
return o;
});
if (Order.ORDER_STATUS_NOT_PAY == order.getStatus()) {
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
int update = jdbcTemplate.update("update t_order set status=?,version=? where id=? and version=? and status=?",
new Object[]{
Order.ORDER_STATUS_PAY_SUCCESS, order.getVersion() + 1, id, order.getVersion(), Order.ORDER_STATUS_NOT_PAY});
if (update > 0) {
log.info("updateStatus success, {}", id);
break;
} else {
log.info("updateStatus failed, {}", id);
}
} else {
log.info("updateStatus status already updated, ignore this request, {}", id);
break;
}
}
log.info("updateStatus end, {}", id);
}
}
运行结果如下：
2020-09-16 14:21:08,934 INFO [t3] (OrderService.java:25) - updateStatus begin, 1
2020-09-16 14:21:08,934 INFO [t2] (OrderService.java:25) - updateStatus begin, 1
2020-09-16 14:21:08,934 INFO [t1] (OrderService.java:25) - updateStatus begin, 1
2020-09-16 14:21:12,110 INFO [t1] (OrderService.java:50) - updateStatus failed, 1
2020-09-16 14:21:12,110 INFO [t2] (OrderService.java:50) - updateStatus failed, 1
2020-09-16 14:21:12,111 INFO [t3] (OrderService.java:47) - updateStatus success, 1
2020-09-16 14:21:12,111 INFO [t3] (OrderService.java:57) - updateStatus end, 1
2020-09-16 14:21:12,117 INFO [t2] (OrderService.java:53) - updateStatus status already updated, ignore this request, 1
2020-09-16 14:21:12,117 INFO [t1] (OrderService.java:53) - updateStatus status already updated, ignore this request, 1
2020-09-16 14:21:12,117 INFO [t1] (OrderService.java:57) - updateStatus end, 1
2020-09-16 14:21:12,117 INFO [t2] (OrderService.java:57) - updateStatus end, 1
总结
悲观锁：会锁住整行记录，导致对数据的其他业务操作也无法进行，效率低，如果sql没写好，可能会产生间隙锁，锁住多条记录，甚至锁住全表。
乐观锁：每个表都需要增加与业务无关的version字段。
优点：直接基于数据库实现，实现简单。
缺点：IO开销大，连接数有限，无法满足高并发的需求。