docs: protected RunnerResult doExecute(Cron4jJob job, TaskExecutionContext context, OptionalThing<LaunchNowOption> nowOption) { // e.g. concurrent control, cross vm
          // ...may be hard to read, synchronized hell
          final String cronExp;
          final VaryingCronOption cronOption;
          debugFw("...Locking varying lock (before run): {}", varyingLock);
          synchronized (varyingLock) {
              cronExp = varyingCron.getCronExp();
              cronOption = varyingCron.getCronOption();
          }
          final List<NeighborConcurrentGroup> neighborConcurrentGroupList = job.getNeighborConcurrentGroupList();
          debugFw("...Locking preparing lock (before run): {}", preparingLock);
          synchronized (preparingLock) { // waiting for previous preparing end
              final OptionalThing<RunnerResult> concurrentResult = stopConcurrentJobIfNeeds(job);
              if (concurrentResult.isPresent()) { // e.g. quit, error
                  return concurrentResult.get();
              }
              // no duplicate or duplicate as waiting, here
              final OptionalThing<RunnerResult> neighborConcurrentResult =
                      synchronizedNeighborPreparing(neighborConcurrentGroupList.iterator(), () -> {
                          final OptionalThing<RunnerResult> result = stopNeighborConcurrentJobIfNeeds(job, neighborConcurrentGroupList);
                          if (!result.isPresent()) { // no duplicate neighbor or duplicate as waiting
                              sleepForLockableLife(); // not to get running lock before previous thread in crevasse point
                              debugFw("...Locking running lock (before run): {}", runningLock);
                              synchronized (runningLock) { // waiting for previous running end
                                  debugFw("...Locking running state in preparing and running lock (before run): {}", runningState);
                                  synchronizedNeighborRunning(neighborConcurrentGroupList.iterator(), () -> { // also neighbor's running
                                      synchronized (runningState) { // to protect running state, begin() and end()
                                          // may be override by crevasse headache, but recover it later
                                          runningState.begin(); // needs to get in preparing lock, to suppress duplicate begin()
                                      }
                                      return null; // unused
                                  });
                              }
                          }
                          return result;
                      });
              if (neighborConcurrentResult.isPresent()) { // e.g. quit, error
                  return neighborConcurrentResult.get();
              }
          }
          // *here is first crevasse point
          // (really want to get running lock before returning preparing lock)
          debugFw("...Locking running lock (before run): {}", runningLock);
          synchronized (runningLock) { // to make next thread wait for me (or waiting by crevasse headache)
              try { // *here is second crevasse point
                  return synchronizedNeighborRunning(neighborConcurrentGroupList.iterator(), () -> {
                      if (!runningState.getBeginTime().isPresent()) { // almost no way, but may be crevasse headache
                          runningState.begin(); // just in case
                      }
                      final OptionalThing<CrossVMState> crossVMState = crossVMBeginning(job);
                      if (crossVMState.isPresent() && crossVMState.get().isQuit()) {
                          return RunnerResult.asQuitByConcurrent(); // quit by cross VM handling
                      }
                      final RunnerResult runnerResult;
                      final LocalDateTime endTime;
                      try {
                          debugFw("...Calling actuallyExecute() of task (before run): {}", job);
                          runnerResult = actuallyExecute(job, cronExp, cronOption, context, nowOption);
                      } finally {
                          debugFw("...Calling finally clause of job execution (after run)");
                          endTime = currentTime.get();
                          crossVMEnding(job, crossVMState, endTime);
                      }
                      runnerResult.acceptEndTime(endTime); // lazy load now
                      return runnerResult;
                  });
              } finally {
                  debugFw("...Locking running state in running lock (after run): {}", runningState);
                  synchronized (runningState) { // running state is only my job so outside neighbor synchronization
                      if (runningState.getBeginTime().isPresent()) {
                          runningState.end(); // for controller dead
                      }
                  }
              }
          }
      }