如何尽快获取锁列表中的锁？

Question

I have this extremely simplified class, running a task under a lock. The lock is there to prevent the same task to run concurrently twice. The task itself can be run as many times as needed.

class Job {
  private Lock lock;
  
  // Constructor, getters, setters, etc. removed to stay short
  
  public boolean execute (int maxWaitTime) {
    if (lock.tryLock(maxWaitTime, TimeUnit.MILISECONDS)) {
      try {
        // do some lengthy job under the lock
      } finally {
        lock.unlock();
      }
    return true;
    }
  else return false;
  }
}

Now, let's say that I have a list of these jobs:

List<Job> jobs = ... ;

All the jobs in the list are of the same nature. I would like to execute only a single one from the list, ignoring all others for the moment. I want to execute the first available task only, waiting as few as possible after currently held locks (corresponding to tasks currently running).

After a while, let's say 10 seconds, if all jobs are still busy, then I give up and don't execute any (in reality, of course, something different happens in that case).

First, I came up with this:

for (Job job: jobs) {
  if (job.execute(10000)) return; // one job has been executed
}

And then realised that, if I had N jobs, then I might end up waiting a total of 10*N seconds instead of only 10 before giving up, in case there's no free job and none become available in the meantime.

Then, I thought about this:

long start = System.currentTimeMillis();
while (true) {
  for (Job job: jobs) {
    if (System.currentTimeMillis() -start > 10000) return; // give up after 10 seconds
    if (job.execute(0)) return; // one job has been executed
  }

I'm not waiting for a running task and just execute the first available within the 10 seconds, and I'm doing it as quick as possible, that's fine. However, I'm doing active wait here, which is known to be terrible for general performances and should be avoided.

My third attempt is:

for (Job job: jobs) {
  if (job.execute(10000/jobs.size())) return; // one job has been executed
}

Now I wait at most 10 seconds as desired. But it isn't the most optimal solution. Let's say I have 10 jobs, the 9th is free, while the first 8 stay running. In that case, I will still wait uselessly for 8 seconds before finding the free one and execute it.

Can we do better ?

As a preference, I would like a standard Java 11 solution without external dependency. The Job class of my example is under my control, so I can refactor it if needed.

Thank you for your answers.

Answer 1

What you need is to try to acquire lock for 10 seconds from N different threads. If you succeed in it raise a flag (you need to do it thread safe) and if flag already raised release current lock otherwise proceed to execute task.

PS: N is number of jobs.