1：分布鎖，我所了解的一共有三種方式

A:傳統的資料庫的全域鎖

B:基于快取的全域鎖，如redis

C:基于zookeeper的分布式鎖

這三種方式的優先機是 C > B > A，因為公司架構問題，最侄訓是選擇了第一種實作方式，所以本文只講述關于資料庫的分布式鎖，以下提供相關知識的幾個鏈接，請自行查閱

分布式鎖的幾種實作方式

Redis分布式鎖的正確實作方式

分布式鎖與實作（二）——基于ZooKeeper實作

2：資料庫全域鎖的優缺點

優點：

簡單易實作

缺點：

A:存在資料庫一般是單點的，一旦資料庫宕機，服務則不可用，

B:鎖沒有失效時間，一旦解鎖失敗則鎖一直存在，導致服務不可用、執行緒阻塞

C:鎖只能是非阻塞的，鎖不可重入

3：資料庫全域鎖的解決方案

1：單點？資料庫可以多搞個資料庫備份，

2：沒有失效時間？定時任務，隔一段時間清理一次，或者每次加鎖時，插入一個期待的有效時間，下次加鎖時則先判斷當前時間是否大于有效時間以此判斷鎖是否失效，

3：非阻塞？開啟另個執行緒回圈獲取

4：非重入，在加鎖時加入機器資訊和執行緒資訊，下次獲取時，先判斷這兩個欄位

4：代碼實體

@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);
		}
	}
}