安科网

定时任务分布式锁的一种实现（数据库锁）

lijianhua

lijianhua

2018-10-27

关注 关注

在集群环境下，若每一台机器都运行一个定时任务，会导致生产数据一致性问题，所以必须要实现一个锁。保证当时任务在同一时间段只能在一台机器上面运行。定时任务实现方式很多种，比较常用的有quartz、TBSchedule等等。低版本的quartz无法满足多个不同的任务同时进行并且不并发执行，尝试了很久quartz还是放弃了。

换了一种思路，自己实现了一种数据库锁的机制，需要创建两张表，一张表来控制任务，另外一张表来记录执行信息。

SQL脚本：

CREATE TABLE qrtz_basejob_config(

key_name varchar(255) DEFAULT '' NOT NULL,

actual_pre_time TIMESTAMP DEFAULT NULL ,

job_state varchar(4) DEFAULT '0' NOT NULL ,

create_time TIMESTAMP DEFAULT NULL,

PRIMARY KEY (key_name)

) ;

COMMENT ON table qrtz_basejob_config

IS

'baseJob配置表';

COMMENT ON column qrtz_basejob_config.key_name

IS

'参数code';

COMMENT ON column qrtz_basejob_config.actual_pre_time

IS

'上一次实际执行时间';

COMMENT ON column qrtz_basejob_config.job_state

IS

'状态--1代表正在执行0代表等待执行';

COMMENT ON column qrtz_basejob_config.create_time

IS

'创建时间';

CREATE TABLE qrtz_basejob_config_record (

id DECIMAL(20) NOT NULL ,

key_name varchar(255) DEFAULT NULL,

start_time timestamp DEFAULT NULL,

end_time timestamp DEFAULT NULL ,

cost_time DECIMAL(20) DEFAULT 0 ,

ip varchar(50) DEFAULT NULL,

create_time timestamp DEFAULT NULL,

PRIMARY KEY (id)

);

COMMENT ON table qrtz_basejob_config_record

IS

'定时任务运行记录表';

COMMENT ON column qrtz_basejob_config_record.id

IS

'主键';

COMMENT ON column qrtz_basejob_config_record.key_name

IS

'定时任务名称';

COMMENT ON column qrtz_basejob_config_record.start_time

IS

'定时任务开始时间';

COMMENT ON column qrtz_basejob_config_record.end_time

IS

'定时任务结束时间';

COMMENT ON column qrtz_basejob_config_record.cost_time

IS

'耗时';

COMMENT ON column qrtz_basejob_config_record.ip

IS

'运行服务器IP';

COMMENT ON column qrtz_basejob_config_record.create_time

IS

'创建时间';

公共任务类：

package com.service.schedulerLockJob.lockJob;

import java.net.InetAddress;

import java.net.UnknownHostException;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Calendar;

import java.util.Date;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.springframework.stereotype.Component;

import com.log.ElectronicsLogger;

import com.service.schedulerLockJob.IBasicJobConfigService;

import com.util.SpringContextHolder;

/**

* 创建日期：2017-11-21上午10:28:36

* 修改日期：

* 作者：ttan

* 描述：

*/

@Component

public abstract class BasicJob{

/*@Autowired(required = false)

@Qualifier("basicJobConfigServiceImpl")

IBasicJobConfigService basicJobConfigService;*/

private IBasicJobConfigService basicJobConfigService = (IBasicJobConfigService) SpringContextHolder.getBean("basicJobConfigServiceImpl");

public static String IP_STRING = null;

static{

try {

InetAddress ip = InetAddress.getLocalHost();

IP_STRING = ip.getHostAddress();

} catch (UnknownHostException e) {

e.printStackTrace();

}

}

/**

*

* 创建日期：2017-11-21下午4:41:22

* 修改日期：

* 作者：ttan

* 描述：

* keyName:任务ID

* resetTime:设置的超时时间

*/

@SuppressWarnings({ "rawtypes", "unchecked" })

public void lockJob(String keyName,String resetTime) throws ParseException {

if(keyName != null && keyName != ""){

SimpleDateFormat format=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

//获取执行时间

Date now = new Date();

String nowTime = format.format(now);

Map baseJobConfig = new HashMap();

baseJobConfig.put("keyName", keyName);

baseJobConfig.put("createTime", nowTime);

List list = basicJobConfigService.getCount(baseJobConfig);

Calendar cal=Calendar.getInstance();

//任务列表无此任务，即初始化

if(list.size()==0||list==null){

baseJobConfig.put("jobState", "0");

cal.setTime(now);

cal.add(Calendar.DAY_OF_MONTH, -1);

String actualPreTime=format.format(cal.getTime());

//为避免初始化任务是出错，将执行时间设置为前一天，即可立即执行

baseJobConfig.put("actualPreTime", actualPreTime);

basicJobConfigService.insertJobConfig(baseJobConfig);

ElectronicsLogger.logger.info("**********************[basicJob.doJob]任务:"+keyName+" 初始化任务到任务列表**********************");

}

int num = 0;

cal.setTime(now);

cal.add(Calendar.MINUTE, -Integer.parseInt(resetTime));

String checkTime = format.format(cal.getTime());

//超时处理： 将状态修改为0

baseJobConfig.put("checkTime", checkTime);

num = basicJobConfigService.updateStateByTimeOut(baseJobConfig);

if(num > 0){

ElectronicsLogger.logger.info("**********************[basicJob.doJob]任务:"+keyName+" 执行超时，已重置任务状态**********************");

}

num = basicJobConfigService.updateStateAtStartTime(baseJobConfig);

if(num > 0){

Date startDate = new Date();

String startTime = format.format(startDate);

ElectronicsLogger.logger.info("**********************[basicJob.doJob]任务:"+keyName+" 执行开始，时间:"+startTime+"**********************");

try {

execute();

} catch (Exception e) {

ElectronicsLogger.logger.error("**********************[basicJob.doJob]任务:"+keyName+" 任务执行中出现异常**********************");

e.printStackTrace();

}finally{

//任务结束后将状态修改为 0

num = basicJobConfigService.updateStateAtEndTime(baseJobConfig);

if(num <= 0){

ElectronicsLogger.logger.error("**********************[basicJob.doJob]任务:"+keyName+" 修改任务状态失败**********************");

}

Date endDate = new Date();

String endTime = format.format(endDate);

long costTime = (endDate.getTime()-startDate.getTime())/1000;//耗时 单位 s

baseJobConfig.put("startTime", startTime);

baseJobConfig.put("endTime", endTime);

baseJobConfig.put("costTime", costTime);

baseJobConfig.put("ipAdress", IP_STRING);

//保存任务执行记录

try {

basicJobConfigService.insertJobConfigRecord(baseJobConfig);

} catch (Exception e) {

e.printStackTrace();

}

ElectronicsLogger.logger.info("**********************[basicJob.doJob]任务:"+keyName+" 执行结束，时间:"+endTime+"耗时:"+costTime+"s**********************");

}

}

}else{

ElectronicsLogger.logger.error("**********************[basicJob.doJob]任务名为空，任务无法执行！**********************");

}

}

//要执行的任务类

public abstract void execute();

}

任务类继承BasicJob，实现execute()方法，例如：

/**

* 创建日期：2017-9-9下午8:54:35

* 修改日期：

* 作者：ttan

*/

package com.service;

import com.service.schedulerLockJob.lockJob.BasicJob;

/**

* 创建日期：2017-9-9下午8:54:35

* 修改日期：

* 作者：ttan

*/

public class TestService extends BasicJob{

@SuppressWarnings("unused")

public void doJob() throws Exception{

super.lockJob("{任务名的ID(唯一)}", "{允许任务超时的分钟数}");

}

@Override

public void execute() {

System.out.printf("测试!!!!~~~~~~~~~~~~~~~~~");

}

}

注意：实际需要触发执行的是doJob方法，实现execute方法，将定时任务要执行的方法放到里面。

以下将一些具体的service和dao贴一下，稍微看一下就明白了。

Service接口:

package com.service.schedulerLockJob;

import java.util.List;

import java.util.Map;

/**

* 创建日期：2017-11-21下午5:19:41

* 修改日期：

* 作者：ttan

* 描述：

*/

public interface IBasicJobConfigService {

/**

*

* 创建日期：2017-11-21上午11:39:58

* 修改日期：

* 作者：ttan

* 描述：判断初始化任务是否存在

*/

@SuppressWarnings("rawtypes")

public List getCount(Map params);

/**

*

* 创建日期：2017-11-21下午2:58:22

* 修改日期：

* 作者：ttan

* 描述：插入任务列表

*/

@SuppressWarnings("rawtypes")

public int insertJobConfig(Map params);

/**

*

* 创建日期：2017-11-21下午2:59:06

* 修改日期：

* 作者：ttan

* 描述：插入运行记录表

* @throws Exception

*/

@SuppressWarnings("rawtypes")

public int insertJobConfigRecord(Map params) throws Exception;

/**

*

* 创建日期：2017-11-21上午11:40:02

* 修改日期：

* 作者：ttan

* 描述：修改状态在超时

*/

@SuppressWarnings("rawtypes")

public int updateStateByTimeOut(Map params);

/**

*

* 创建日期：2017-11-21上午11:40:05

* 修改日期：

* 作者：ttan

* 描述：修改状态在开始时间

*/

@SuppressWarnings("rawtypes")

public int updateStateAtStartTime(Map params);

/**

*

* 创建日期：2017-11-21上午11:40:08

* 修改日期：

* 作者：ttan

* 描述：修改状态在结束时间

*/

@SuppressWarnings("rawtypes")

public int updateStateAtEndTime(Map params);

}

Service实现类：

package com.service.schedulerLockJob.impl;

import java.util.List;

import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.stereotype.Service;

import com.dao.SequenceDao;

import com.dao.schedulerLockJob.IBasicJobConfigDao;

import com.service.schedulerLockJob.IBasicJobConfigService;

/**

* 创建日期：2017-11-21下午5:20:05

* 修改日期：

* 作者：ttan

* 描述：

*/

@Service("basicJobConfigServiceImpl")

public class BasicJobConfigServiceImpl implements IBasicJobConfigService{

@Autowired(required = false)

@Qualifier("basicJobConfigDaoImpl")

IBasicJobConfigDao basicJobConfigDao;

@SuppressWarnings("rawtypes")

@Override

public List getCount(Map params) {

return basicJobConfigDao.getCount(params);

}

@SuppressWarnings("rawtypes")

@Override

public int insertJobConfig(Map params) {

return basicJobConfigDao.insertJobConfig(params);

}

@SuppressWarnings({ "rawtypes", "unchecked" })

@Override

public int insertJobConfigRecord(Map params) throws Exception {

SequenceDao seqDao = new SequenceDao();

String id = seqDao.getGenratorId("QRTZ_BASEJOB_CONFIG_RECORD");

if(id==null||"".equals(id)){

throw new Exception("获取数据库序列失败！");

}

params.put("id", id);

return basicJobConfigDao.insertJobConfigRecord(params);

}

@SuppressWarnings("rawtypes")

@Override

public int updateStateByTimeOut(Map params) {

return basicJobConfigDao.updateStateByTimeOut(params);

}

@SuppressWarnings("rawtypes")

@Override

public int updateStateAtStartTime(Map params) {

return basicJobConfigDao.updateStateAtStartTime(params);

}

@SuppressWarnings("rawtypes")

@Override

public int updateStateAtEndTime(Map params) {

return basicJobConfigDao.updateStateAtEndTime(params);

}

}

Dao接口：

package com.dao.schedulerLockJob;

import java.util.List;

import java.util.Map;

/**

* 创建日期：2017-11-21上午11:36:57

* 修改日期：

* 作者：ttan

* 描述：

*/

public interface IBasicJobConfigDao {

/**

*

* 创建日期：2017-11-21上午11:39:58

* 修改日期：

* 作者：ttan

* 描述：判断初始化任务是否存在

*/

@SuppressWarnings("rawtypes")

public List getCount(Map params);

/**

*

* 创建日期：2017-11-21下午2:58:22

* 修改日期：

* 作者：ttan

* 描述：插入任务列表

*/

@SuppressWarnings("rawtypes")

public int insertJobConfig(Map params);

/**

*

* 创建日期：2017-11-21下午2:59:06

* 修改日期：

* 作者：ttan

* 描述：插入运行记录表

*/

@SuppressWarnings("rawtypes")

public int insertJobConfigRecord(Map params);

/**

*

* 创建日期：2017-11-21上午11:40:02

* 修改日期：

* 作者：ttan

* 描述：修改状态在超时

*/

@SuppressWarnings("rawtypes")

public int updateStateByTimeOut(Map params);

/**

*

* 创建日期：2017-11-21上午11:40:05

* 修改日期：

* 作者：ttan

* 描述：修改状态在开始时间

*/

@SuppressWarnings("rawtypes")

public int updateStateAtStartTime(Map params);

/**

*

* 创建日期：2017-11-21上午11:40:08

* 修改日期：

* 作者：ttan

* 描述：修改状态在结束时间

*/

@SuppressWarnings("rawtypes")

public int updateStateAtEndTime(Map params);

}

Dao实现类：

package com.dao.schedulerLockJob.impl;

import java.sql.Timestamp;

import java.util.List;

import java.util.Map;

import org.springframework.stereotype.Repository;

import com.dao.JdbcTemplateSupport;

import com.dao.schedulerLockJob.IBasicJobConfigDao;

import com.util.DateUtil;

import com.util.string.StringUtil;

/**

* 创建日期：2017-11-21下午2:18:10

* 修改日期：

* 作者：ttan

* 描述：

*/

@Repository("basicJobConfigDaoImpl")

public class BasicJobConfigDaoImpl extends JdbcTemplateSupport implements IBasicJobConfigDao {

@SuppressWarnings("rawtypes")

@Override

public List getCount(Map params) {

String sql = "SELECT * FROM QRTZ_BASEJOB_CONFIG WHERE KEY_NAME = ?";

String KEY_NAME = StringUtil.toString(params.get("keyName"));

return this.query(sql,new Object[]{KEY_NAME});

}

@SuppressWarnings("rawtypes")

@Override

public int updateStateByTimeOut(Map params) {

String sql = "UPDATE QRTZ_BASEJOB_CONFIG SET JOB_STATE = '0' " +

"WHERE KEY_NAME = ? AND JOB_STATE = '1' " +

"AND ACTUAL_PRE_TIME <= ?";

String KEY_NAME = StringUtil.toString(params.get("keyName"));

String checkTime = StringUtil.toString(params.get("checkTime"));

Timestamp timeStamp1 = DateUtil.convertStringToTimestamp(checkTime, "1");

return this.update(sql, new Object[]{KEY_NAME,timeStamp1});

}

@SuppressWarnings("rawtypes")

@Override

public int updateStateAtStartTime(Map params) {

String sql ="UPDATE QRTZ_BASEJOB_CONFIG SET JOB_STATE = '1', " +

"ACTUAL_PRE_TIME = current timestamp WHERE KEY_NAME = ? " +

"AND JOB_STATE = '0'";

String KEY_NAME = StringUtil.toString(params.get("keyName"));

return this.update(sql, new Object[]{KEY_NAME});

}

@SuppressWarnings("rawtypes")

@Override

public int updateStateAtEndTime(Map params) {

String sql ="UPDATE QRTZ_BASEJOB_CONFIG SET JOB_STATE = '0' " +

"WHERE KEY_NAME = ? " +

"AND JOB_STATE = '1'";

String KEY_NAME = StringUtil.toString(params.get("keyName"));

return this.update(sql, new Object[]{KEY_NAME});

}

@SuppressWarnings("rawtypes")

@Override

public int insertJobConfig(Map params) {

String sql = "INSERT INTO QRTZ_BASEJOB_CONFIG(KEY_NAME,JOB_STATE,ACTUAL_PRE_TIME,CREATE_TIME) VALUES(?,?,?,?)";

String KEY_NAME = StringUtil.toString(params.get("keyName"));

String JOB_STATE = StringUtil.toString(params.get("jobState"));

String ACTUAL_PRE_TIME = StringUtil.toString(params.get("actualPreTime"));

String CREATE_TIME = StringUtil.toString(params.get("createTime"));

Timestamp timeStamp1 = DateUtil.convertStringToTimestamp(ACTUAL_PRE_TIME, "1");

Timestamp timeStamp2 = DateUtil.convertStringToTimestamp(CREATE_TIME, "1");

return this.update(sql, new Object[]{KEY_NAME,JOB_STATE,timeStamp1,timeStamp2});

}

@SuppressWarnings("rawtypes")

@Override

public int insertJobConfigRecord(Map params) {

String sql = "INSERT INTO QRTZ_BASEJOB_CONFIG_RECORD(ID,KEY_NAME,START_TIME,END_TIME,COST_TIME,IP,CREATE_TIME) " +

"VALUES(?,?,?,?,?,?,?)";

long ID = Long.parseLong(StringUtil.toString(params.get("id")));;

String KEY_NAME = StringUtil.toString(params.get("keyName"));

String START_TIME_STR = StringUtil.toString(params.get("startTime"));

String END_TIME_STR = StringUtil.toString(params.get("endTime"));

long COST_TIME = (Long) params.get("costTime");

String IP = StringUtil.toString(params.get("ipAdress"));

String CREATE_TIME_STR = StringUtil.toString(params.get("createTime"));

Timestamp START_TIME = DateUtil.convertStringToTimestamp(START_TIME_STR, "1");

Timestamp END_TIME = DateUtil.convertStringToTimestamp(END_TIME_STR, "1");

Timestamp CREATE_TIME = DateUtil.convertStringToTimestamp(CREATE_TIME_STR, "1");

return this.update(sql,new Object[]{ID,KEY_NAME,START_TIME,END_TIME,COST_TIME,IP,CREATE_TIME});

}

}

总结：经过一部分测试，暂时没有发现什么问题，缺乏大剂量数据操作的测试。 不过合理设置超时时间基本可以避免数据的出错。

定时任务分布式锁的一种实现（数据库锁）

医学医生手工作与现代计算机接口

分布式锁 时间戳

lijianhua

lijianhua

0 关注 0 粉丝 0 动态

关注 关注

相关推荐

Redis 的并发竞争问题是什么？如何解决这个问题？了解 redis 事务的 CAS 方案吗？

而且 redis 自己就有天然解决这个问题的 CAS 类的乐观锁方案。某个时刻，多个系统实例都去更新某个 key。每次要写之前，先判断一下当前这个 value 的时间戳是否比缓存里的 value 的时间戳要新。

manongxiaomei 2020-07-05

php redis setnx分布式锁简单原理解析

我就废话不多说了，大家还是直接看代码吧~如果一个请求更新缓存的时间比较长，甚至比锁的有效期还要长，导致在缓存更新过程中，锁就失效了，此时另一个请求会获取锁，但前一个请求在缓存更新完毕的时候，如果不加以判断直接删除锁，就会出现误删除其它请求创建的锁的情况，所

savorTheFlavor 2020-10-23

程序员必懂的Redis技术实战

Redis是现在很受欢迎的NoSQL数据库之一，目前广泛用于缓存系统、分布式锁、计数器、消息队列系统、排行榜、社交网络等场景中，本篇文章成哥为大家带来redis日常使用实践，及通过代码实现redis的分布式锁。Redis通过IO多路复用解决单线程下并发客户

smartbaby 2020-11-11

redis的设计及使用场景

redis是一个完全开源的，高性能的key-value数据库，特点是：支持原子性、持久化、丰富的数据类型。在使用redis的时候，要注意的key设计，这样易于维护，考虑持久化策略，以防在服务异常的时候快速的恢复数据；考虑系统的安全策略，不能使用key *命

夙梦流尘 2020-09-23

springboot redis lua脚本分布式锁

* @param value redis的value要求是随机串，防止释放其他请求的锁。* @param expireTime redis的key 的过期时间 防止死锁，导致其他请求无法正常执行业务。String script =

峰哥 2020-09-23

分布式事务、分布式锁、分布式缓存

分布式应用：一个服务需要对多个不同的数据库进行操作，保证同时成功或失败。

summerZBH 2020-09-23

每秒上千订单场景下的分布式锁高并发优化实践！

本文转载自微信公众号「石杉的架构笔记」，作者中华石杉 。假如下单时，用分布式锁来防止库存超卖，但是是每秒上千订单的高并发场景，如何对分布式锁进行高并发优化来应对这个场景?比如让面试的同学聊一聊电商高并发秒杀场景下的库存超卖解决方案，各种方案的优缺点以及实践

互联网架构之路 2020-09-03

redis单节点及集群搭建

redis-cli --cluster create 127.0.0.1:6380 127.0.0.1:6381 127.0.0.1:6382 127.0.0.1:6390 127.0.0.1:6391 127.0.0.1:6392 --cluster-r

zhangll00 2020-07-29

Redis 5.0部署

* 基于键值对的数据结构服务器：redis中的值不仅仅可以是字符串，关于其支持的数据类型已经在文章开头列出来了。* 1.键过期功能，用来实现缓存。* 2.发布订阅功能，用来实现消息系统。* 3.支持Lua脚本，可以利用Lua创造出新的Redis命令。* 4

大胡子抽雪茄 2020-07-19

redis 应用场景

若给定的 key 已经存在，则setnx不做任何动作，返回0。当setnx返回1时，表示获取锁，做完操作以后del key，表示释放锁，如果setnx返回0表示获取锁失败。比如我们要存储用户信息，ID、姓名、电话、年龄、身高 ，怎么存储？查询时，取出key

middleware0 2020-07-19

掌握Redis分布式锁的正确姿势

在Java中，我们对于锁会比较熟悉，常用的有 synchronized、Lock锁，在java并发编程中，我们通过锁，来实现当多个线程竞争同一个共享资源或者变量而造成的数据不一致的问题，但是JVM锁只能针对于单个应用服务，随着我们业务的发展需要，单体单机部

Cheetahcubs 2020-07-18

如何用Redis实现分布式锁

在实际的开发场景中，我们可能会遇到不同客户端需要互斥地访问某个共享资源，也就是同一时刻只允许一个客户端操作这个共享资源，为了达到这个目的，一般会采用分布式锁来解决，目前流行的分布式锁实现方式有数据库、Memcached、Redis、文件系统、ZooKeep

wqbala 2020-07-04

分布式锁讲解

首先，分布式锁和我们平常讲到的锁原理基本一样，目的就是确保在多个线程并发时，只有一个线程在同一刻操作这个业务或者说方法、变量。想想双十一和大年三十晚上十点，瓜分支付宝红包等业务场景，自然需要用到多台服务器去同时处理这些业务，这些服务可能会有上百台同时处理。

憧憬 2020-07-04

幂等性

幂等性的 6 种实现方式，包括前端拦截、数据库悲观锁实现、数据唯一索引实现、数据库乐观锁实现、JVM 锁实现，以及分布式锁的实现等方案，其中前端拦截无法防止懂行的人直接绕过前端进行模拟请求的操作。因此后端一定要实现幂等性处理，推荐的做法是使用分布式锁来实现

caifengguo 2020-06-28

如何设计高性能的分布式锁

什么是分布式锁？在 JVM 中，在多线程并发的情况下，我们可以使用同步锁或 Lock 锁，保证在同一时间内，只能有一个线程修改共享变量或执行代码块。但现在我们的服务都是基于分布式集群来实现部署的，对于一些共享资源，在分布式环境下使用 Java 锁的方式就失

亦碎流年 2020-06-18

Java 中利用 redis 实现一个分布式锁服务

在现代的编程语言中，接触过多线程编程的程序员多多少少对锁有一定的了解。简单的说，多线程中的锁就是在多线程环境下，多个线程对共享资源进行修改的时候，保证共享资源一致性的机制。在分布式环境下实现一个分布式锁服务并不太容易，需要考虑很多在单进程下的锁服务不需要考

loviezhang 2020-06-17

老大吩咐的可重入分布式锁，终于实现了~

本文转载自微信公众号「程序通事」，作者楼下小黑哥。最近在做一个项目，将一个其他公司的实现系统，完整的整合到自己公司的系统中，这其中需要将对方实现的功能完整在自己系统也实现一遍。旧系统还有一批存量商户，为了不影响存量商户的体验，新系统提供的对外接口，还必须得

wangyjbk 2020-06-15

如此通俗的分布式锁讲解，如果还搞不定那就...

首先，分布式锁和我们平常讲到的锁原理基本一样，目的就是确保在多个线程并发时，只有一个线程在同一刻操作这个业务或者说方法、变量。想想双十一和大年三十晚上十点，瓜分支付宝红包等业务场景，自然需要用到多台服务器去同时处理这些业务，这些服务可能会有上百台同时处理。

wqbala 2020-06-14

基于redis实现分布式锁的原理与方法

系统的不断扩大，分布式锁是最基本的保障。与单机的多线程不一样的是，分布式跨多个机器。线程的共享变量无法跨机器。为了保证一个在高并发存场景下只能被同一个线程操作，java并发处理提供ReentrantLock或Synchronized进行互斥控制。但是这仅仅

hweiyi 2020-06-14

redis 分布式锁基本实现

import cn.xa87.common.lock.AbstractDistributedLock;import lombok.extern.slf4j.Slf4j;import org.springframework.data.redis.core.R

manongxiaomei 2020-06-12
lijianhua

lijianhua

W3CSchool教程
HTML 教程
CSS 教程
Bootstrap 教程
Javascript 教程
jQuery 教程
后端教程
C 教程
Java 教程
PHP 教程
Python 教程
Go 教程
移动开发
Android 教程
Swift 教程
Kotlin 教程
jQuery Mobile 教程
ionic 教程
关于我们
新闻动态
联系方式
招聘英才
安科实验室
帮助与反馈

安科网(Ancii)，中国第一极客网

Copyright © 2013 - 2019 Ancii.com

京ICP备18063983号 京公网安备11010802014868号