Java 如何在spring boot中实现单线程调度程序？

我希望每00秒（服务器时间）执行一次进程
但是，这些过程可能需要一分钟或更长时间

当进程仍在运行时，
是否有优雅的方法阻止同一进程（方法）运行？（我不想运行该进程）

（如果过程2结束，
即使进程1正在运行，进程2也必须独立运行。）

---

我自己用下面的源代码解决了这个问题

@Service
public class Scheduler {
    @Autowired
    private Job1Service job1;   
    @Autowired
    private Job2Service job2;

    @Scheduled(cron = "0 * * * * ?")
    private void job1() {
        new Thread(job1).start();
    }

    @Scheduled(cron = "0 * * * * ?")
    private void job2() {
        new Thread(job2).start();
    }}
}

公共类Job1ServiceImpl实现Job1Service，可运行{
私有最终重入锁定=新重入锁定（true）；
公开募捐{
试一试{
if（lock.tryLock（1，时间单位毫秒））{
试一试{
logger.info（“作业1启动”）；
/*干重活
对于（int i=0；i<100；i++）{
logger.info（“测试1:+i”）；
对于（int j=0；j<9999999；j++）{
int k=1；
k++；
k++；
}
}
*/
}捕获（例外e）{
记录器错误（“作业1错误”，e）；
}最后{
logger.info（“作业1结束”）；
lock.unlock（）；
}
}否则{
logger.info（“跳过作业1。作业1仍在运行”）；
}
}捕捉（中断异常e）{
logger.info（“作业1中止”，e）；
}
}
}

公共类Job2ServiceImpl实现Job2Service，可运行{
私有最终重入锁定=新重入锁定（true）；
公开募捐{
试一试{
if（lock.tryLock（1，时间单位毫秒））{
试一试{
logger.info（“作业2启动”）；
/*干重活
对于（int i=0；i<100；i++）{
logger.info（“测试2:+i”）；
对于（int j=0；j<9999999；j++）{
int k=1；
k++；
k++；
}
}
*/
}捕获（例外e）{
记录器错误（“作业2错误”，e）；
}最后{
logger.info（“作业2结束”）；
lock.unlock（）；
}
}否则{
logger.info（“跳过作业2。作业2仍在运行”）；
}
}捕捉（中断异常e）{
logger.info（“作业2中止”，e）；
}
}
}

你不想理解的是什么，比如你想说process2独立运行，而不受process1（process1完成或运行）或其他什么的影响？是的，没错……那么上面代码中的问题是什么，但我不想两个或多个相同的进程（方法）同时运行。你自相矛盾：“如果过程1结束。。。即使进程#1正在运行”-它怎么能结束并同时运行？

@Service
public class Scheduler {
    @Autowired
    private Job1Service job1;   
    @Autowired
    private Job2Service job2;

    @Scheduled(cron = "0 * * * * ?")
    private void job1() {
        new Thread(job1).start();
    }

    @Scheduled(cron = "0 * * * * ?")
    private void job2() {
        new Thread(job2).start();
    }}
}

public class Job1ServiceImpl implements Job1Service, Runnable{
    private final ReentrantLock lock = new ReentrantLock(true);

    public void run() {
        try {
            if(lock.tryLock(1, TimeUnit.MILLISECONDS)) {
                try {
                    logger.info("job1 start");

                    /* do heavy job
                    for(int i = 0 ; i < 100 ; i++) {
                        logger.info("test#1 : " + i);
                        for(int j = 0 ; j < 999999999 ; j++) {
                            int k = 1;
                            k++;
                            k++;
                        }
                    }
                    */
                }catch(Exception e) {
                    logger.error("job#1 error", e);
                }finally {
                    logger.info("job #1 end");
                    lock.unlock();
                }
            }else {
                logger.info("skip job#1. job #1 is running still");
            }
        }catch(InterruptedException e) {
            logger.info("Job #1 Aborted", e);
        }
    }
}

public class Job2ServiceImpl implements Job2Service, Runnable{
    private final ReentrantLock lock = new ReentrantLock(true);

    public void run() {
        try {
            if(lock.tryLock(1, TimeUnit.MILLISECONDS)) {
                try {
                    logger.info("job2 start");

                    /* do heavy job
                    for(int i = 0 ; i < 100 ; i++) {
                        logger.info("test#2 : " + i);
                        for(int j = 0 ; j < 999999999 ; j++) {
                            int k = 1;
                            k++;
                            k++;
                        }
                    }
                    */
                }catch(Exception e) {
                    logger.error("job#2 error", e);
                }finally {
                    logger.info("job #2 end");
                    lock.unlock();
                }
            }else {
                logger.info("skip job#2. job #2 is running still");
            }
        }catch(InterruptedException e) {
            logger.info("Job #2 Aborted", e);
        }
    }
}