Java 中的随机 for 循环？

Question

I have 25 batch jobs that are executed constantly, that is, when number 25 is finished, 1 is immediately started.

These batch jobs are started using an URL that contains the value 1 to 25. Basically, I use a for loop from 1 to 25 where I, in each round, call en URL with the current value of i , http://batchjobserver/1 , http://batchjobserver/2 and so on.

The problem is that some of these batch jobs are a bit unstable and sometimes crashes which causes the for-loop to restart at 1. As a consequence, batch job 1 is run every time the loop is initiated while 25 runs much less frequently.

I like my current solution because it is so simple (in pseudo code)

for (i=1; i < 26; i++) {
   getURL ("http://batchjob/" + Integer.toString(i));
}

However, I would like I to be a random number between 1 and 25 so that, in case something crashes, all the batch jobs, in the long run, are run approximately the same number of times.

Is there some nice hack/algorithm that allows me to achieve this?

Other requirements:

• The number 25 changes frequently
• This is not an absolut requirement but it would be nice one batch job wasn't run again until all other all other jobs have been attempted once. This doesn't mean that they have to "wait" 25 loops before they can run again, instead - if job 8 is executed in the 25th loop (the last loop of the first "set" of loops), the 26th loop (the first loop in the second set of loops) can be 8 as well.

Randomness has another advantage: it is desirable if the execution of these jobs looks a bit manual.

Answer 1

To handle errors, you should use a try-catch statement. It should look something like this:

for(int i = 1, i<26, i++){
   try{
      getURL();
   }
   catch (Exception e){
      System.out.print(e);
   }
}

This is a very basic example of what can be done. This will, however, only skip the failed attempts, print the error, and continue to the next iteration of the loop.

Answer 2

There are two parts of your requirement:

1. Randomness : For this, you can use Random#nextInt .
2. Skip the problematic call and continue with the remaining ones : For this, you can use a try-catch block.

Code:

Random random = new Random();
for (i = 1; i < 26; i++) {
    try {
        getURL ("http://batchjob/" + Integer.toString(random.nextInt(25) + 1));
    } catch (Exception e) {
        System.out.println("Error: " + e.getMessage());
    }
}

Note: random.nextInt(25) returns an int value from 0 to 24 and thus, when 1 is added to it, the range becomes 1 to 25 .

Answer 3

You could use a set and start randomizing numbers in the range of your batches, while doing this you will be tracking which batch you already passed by adding them to the set, something like this:

int numberOfBatches = 26;
Set<Integer> set = new HashSet<>();
List<Integer> failedBatches = new ArrayList<>();
Random random = new Random();
while(set.size() <= numberOfBatches)
{
     int ran = random.nextInt(numberOfBatches) + 1;
     if(set.contains(ran)) continue;
     set.add(ran);
     try
     {
         getURL ("http://batchjob/" + Integer.toString(ran));
     } catch (Exception e)
     {
         failedBatches.add(ran);
     }
}

As an extra, you can save which batches failed

Answer 4

The following is an example of a single-threaded, infinite looping (also colled Round-robin ) scheduler with simple retry capabilities. I called "scrape" the routine that calls your batch job ( scraping means indexing a website contents):

public static void main(String... args) throws Exception {
    Runnable[] jobs = new Runnable[]{
            () -> scrape("https://www.stackoverfow.com"),
            () -> scrape("https://www.github.com"),
            () -> scrape("https://www.facebook.com"),
            () -> scrape("https://www.twitter.com"),
            () -> scrape("https://www.wikipedia.org"),
    };

    for (int i = 0; true; i++) {
        int remainingAttempts = 3;
        while (remainingAttempts > 0) {
            try {
                jobs[i % jobs.length].run();
                break;
            } catch (Throwable err) {
                err.printStackTrace();
                remainingAttempts--;
            }
        }
    }
}

private static void scrape(String website) {
    System.out.printf("Doing my job against %s%n", website);
    try {
        Thread.sleep(100); // Simulate network work
    } catch (InterruptedException e) {
        throw new RuntimeException("Requested interruption");
    }
    if (Math.random() > 0.5) {   // Simulate network failure
        throw new RuntimeException("Ooops! I'm a random error");
    }
}

You may want to add multi-thread capabilities (that is achieved by simply adding an ExecutorService guarded by a Semaphore ) and some retry logic (for example only for certain type of errors and with a exponential backoff).