1: Cerraduras distribuidas, hay tres formas que conozco
A: bloqueo global de base de datos tradicional
B: bloqueo global basado en caché, como redis
C: bloqueo distribuido basado en zookeeper
La prioridad de estos tres métodos es C> B> A. Debido a la estructura de la empresa, finalmente se eligió el primer método de implementación. Entonces, este artículo solo habla de bloqueos distribuidos en la base de datos. Aquí hay algunos enlaces a conocimientos relacionados, compruébelo usted mismo
Varios métodos de implementación de bloqueos distribuidos
La correcta implementación de los bloqueos distribuidos de Redis
Bloqueo e implementación distribuidos (dos) basados en la implementación de ZooKeeper
2: ventajas y desventajas del bloqueo global de la base de datos
ventaja:
Simple y fácil de implementar
Desventajas:
R: La existencia de una base de datos es generalmente un solo punto, una vez que la base de datos está inactiva. Los servicios no están disponibles.
B: El bloqueo no tiene fecha de caducidad. Una vez que el desbloqueo falla, el bloqueo siempre existirá, lo que provocará la indisponibilidad de los servicios y el bloqueo de subprocesos.
C: La cerradura solo puede ser sin bloqueo, la cerradura no puede volver a entrar
3: la solución al bloqueo global de la base de datos
1: ¿Un solo punto? La base de datos puede realizar más copias de seguridad de la base de datos.
2: ¿Sin tiempo de caducidad? Tareas programadas, limpie de vez en cuando. O cada vez que se bloquea un bloqueo, se inserta un tiempo efectivo esperado y la próxima vez que se bloquea el bloqueo, se juzga si el tiempo actual es mayor que el tiempo efectivo para determinar si el bloqueo no es válido.
3: ¿Sin bloqueo? Abra otro hilo para obtener el bucle
4: No reentrante, agregue la información de la máquina y la información del hilo al bloquear, y juzgue estos dos campos primero al adquirir la próxima vez
4: ejemplo de código
@Component
public class ArchiveTask {
private ThreadPoolTaskScheduler scheduler = null;
private ArchiveTaskDAO dao;
private ScheduledFuture<?> future;
private String clearDataDay = "90"; //默认迁移90天前的数据
private String wfmProcedure = null;
public static String stype = "TASK_SCHEDULER";
public static String pkey = "WFM_ARCHIVE_TASK";
public static String lock = "lock"; // 上锁状态
public static String unLock = "unLock"; // 无锁状态
public static String errorLock = "errorLock"; // 发生了错误
public static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
private boolean isLock = false;
//private Logger logger = LoggerFactory.getLogger(ArchiveTask.class);
public void init(){
scheduler = new ThreadPoolTaskScheduler();
dao = (ArchiveTaskDAO) BaseDAOFactory.getDAO(ArchiveTaskDAO.class.getName());
wfmProcedure = Optional.ofNullable(dao.getConfigByType("ORDER", "HIS_SAVE_ORDERHIS_BY_ORDERID"))
.orElse("HIS_SAVE_ORDERHIS_BY_ORDERID");
}
public void schedule(){
scheduler.initialize();
future = scheduler.schedule(()->{
// 执行任务
runTask();
}, new Trigger(){
// 先执行 Trigger,在执行 Runnable
@Override
public Date nextExecutionTime(TriggerContext triggerContext) {
// TODO Auto-generated method stub
Date nextExecDate = null;
try {
//查询定时计划
Map<String,Object> taskMap = dao.getTaskSchedulerCron();
String cron = MapUtils.getString(taskMap, "cron", "");
if(cron.equals("")) {
return null;
}
// 定时任务触发,可修改定时任务的执行周期。数据库修改即可,不用重启应用。
CronTrigger trigger = new CronTrigger(cron);
nextExecDate = trigger.nextExecutionTime(triggerContext);
//计算时间差
Long timeDiffSecond = (nextExecDate.getTime() - new Date().getTime())/1000;
dao.updateTaskNextTimeDiff(timeDiffSecond.toString());
}catch (Exception e) {
e.printStackTrace();
}
return nextExecDate;
}
});
}
public void stop(){
future.cancel(true);
}
public void reStart(){
future.cancel(true);
schedule();
}
public void test(){
// 不通过定时任务,测试
scheduler.initialize();
scheduler.execute(()->{
runTask();
});
}
private void runTask(){
try{
Map<String,Object> taskMap = dao.getTaskSchedulerCron();
//0) 功能开关,如果关闭则直接跳过
String openStatus = MapUtils.getString(taskMap, "openStatus","");
if(!openStatus.equals("open")){
return;
}
//1)查询锁的有效时间
boolean lockValid = true; // 判断之前的加锁时间是否有效
String timeDiffSecondStr = MapUtils.getString(taskMap, "timeDiffSecond","");
String modifyDay = MapUtils.getString(taskMap, "modifyDay", ""); // 最近修改锁时间
if(modifyDay.equals("")||timeDiffSecondStr.equals("")){
lockValid = false;
}else{
Long timeDiffSecond = Long.parseLong(timeDiffSecondStr);
Date modifyDate = sdf.parse(modifyDay);
Calendar tmpCal = Calendar.getInstance();
tmpCal.setTime(modifyDate);
tmpCal.add(Calendar.SECOND, timeDiffSecond.intValue());
Date curDateForValid = tmpCal.getTime(); //锁的有效时间
Date curDate = new Date();
if(curDate.after(curDateForValid)){
//锁失效
lockValid = false;
}
}
//2) 先判断是否已有其他线程、进程在执行数据迁移任务了,数据库锁
synchronized (ArchiveTask.class) {
int flag = dao.taskSchedulerLock(lockValid);
if(flag < 1){
// 无法加锁,已被其他任务锁住了
return;
}
isLock = true;
}
//3)查询需要迁移的数据
Calendar cal = Calendar.getInstance();
String dayStr = MapUtils.getString(taskMap, "day", clearDataDay);
Integer dayI = Integer.parseInt(dayStr);
cal.add(Calendar.DAY_OF_YEAR, - dayI.intValue());
Date endDate = cal.getTime(); // 截止日期
Map<String,Object> params = new HashMap<String, Object>();
params.put("endDate", endDate);
params.put("iomBaseDataName", iomBaseDataName);
//4) (逻辑处理)
//更新锁状态
dao.updateTaskSchedulerLock(unLock);
isLock = false;
}catch(Exception ex){
ex.printStackTrace();
//如果出错 则更新数据库锁 为 出错状态
dao.updateTaskSchedulerLock(errorLock);
isLock = false;
}
}
public void releaseLock(){
if(isLock==true){
dao.updateTaskSchedulerLock(unLock);
}
}
}