docs: public void unlock(final Task task, final Interval interval)
    {
      giant.lock();
  
      try {
        final String dataSource = task.getDataSource();
        final NavigableMap<DateTime, SortedMap<Interval, List<TaskLockPosse>>> dsRunning = running.get(task.getDataSource());
  
        if (dsRunning == null || dsRunning.isEmpty()) {
          return;
        }
  
        final SortedMap<Interval, List<TaskLockPosse>> intervalToPosses = dsRunning.get(interval.getStart());
  
        if (intervalToPosses == null || intervalToPosses.isEmpty()) {
          return;
        }
  
        final List<TaskLockPosse> possesHolder = intervalToPosses.get(interval);
        if (possesHolder == null || possesHolder.isEmpty()) {
          return;
        }
  
        final List<TaskLockPosse> posses = possesHolder.stream()
                                                       .filter(posse -> posse.containsTask(task))
                                                       .collect(Collectors.toList());
  
        for (TaskLockPosse taskLockPosse : posses) {
          final TaskLock taskLock = taskLockPosse.getTaskLock();
  
          // Remove task from live list
          log.info("Removing task[%s] from TaskLock[%s]", task.getId(), taskLock.getGroupId());
          final boolean removed = taskLockPosse.removeTask(task);
  
          if (taskLockPosse.isTasksEmpty()) {
            log.info("TaskLock is now empty: %s", taskLock);
            possesHolder.remove(taskLockPosse);
          }
  
          if (possesHolder.isEmpty()) {
            intervalToPosses.remove(interval);
          }
  
          if (intervalToPosses.isEmpty()) {
            dsRunning.remove(interval.getStart());
          }
  
          if (running.get(dataSource).size() == 0) {
            running.remove(dataSource);
          }
  
          // Wake up blocking-lock waiters
          lockReleaseCondition.signalAll();
  
          // Remove lock from storage. If it cannot be removed, just ignore the failure.
          try {
            taskStorage.removeLock(task.getId(), taskLock);
          }
          catch (Exception e) {
            log.makeAlert(e, "Failed to clean up lock from storage")
               .addData("task", task.getId())
               .addData("dataSource", taskLock.getDataSource())
               .addData("interval", taskLock.getInterval())
               .addData("version", taskLock.getVersion())
               .emit();
          }
  
          if (!removed) {
            log.makeAlert("Lock release without acquire")
               .addData("task", task.getId())
               .addData("interval", interval)
               .emit();
          }
        }
      }
      finally {
        giant.unlock();
      }
    }