使用线程生成唯一随机数（范围）的简单方法？ 爪哇

Question

I want to generate a list of unique random numbers from a given input range using threads in Java. For example, given a range of 1-4, I would run 4 threads and each thread would generate a random number such that no two threads would produce the same value twice. I presume I need to implement some synchronization or something? I've tried using Join() but it doesn't seem to work.

My constructor uses input values to populate an array list with a given range. In the run method, I generate a random value (from the same range) and check if it's in the list. If it is, I remove it from the list and print the value. The idea is that when another thread comes in, it can't generate that same value again.

Here is what I have so far:

public class Main {

public static void main(String[] args) {
    randomThreadGen randomRange = new randomThreadGen(1, 2);
    Thread thread1 = new Thread(randomRange);
    Thread thread2 = new Thread(randomRange);

    thread1.start();
    try {
        thread1.join();
    } catch (InterruptedException e) {
    }

    thread2.start();
}
}

And this:

public class randomThreadGen implements Runnable {

private int lowerBound;
private int upperBound;
private final ArrayList<Integer> List = new ArrayList<Integer>();

public randomThreadGen(int lowerb, int upperb) {
    this.lowerBound = lowerb;
    this.upperBound = upperb;
    for (int i = lowerb; i < upperb + 1; i++) { // populate list with values based on lower and upperbounds specified from main
        List.add(i);
    }

}

@Override
public void run() {
    // generate random value
    // check if in list. If in list, remove it
    // print value
    // otherwise try again
    int val = ThreadLocalRandom.current().nextInt(lowerBound, upperBound+1); // generate random value based on lower and upper bound inputs from main
    
    while(true){
        if(List.contains(val)){
            List.remove(new Integer(val));
            System.out.println("Random value for " + Thread.currentThread().getName() + "  " + val);
            System.out.println("List values:  " + List);
        }
        break;
        
    }
    
    }
}'''

This test case with a low range is to make testing easy. Sometimes it works, and Thread0 will generate a different value to Thread01 (1 and 2 or 2 and 1 for example). But sometimes it doesn't (seemingly they generate the same value, in which case my code only prints one value) For example, "Thread02 1" and nothing else.

Any ideas? Is there another way to do this other than join() ?

Answer 1

It's quite an easy task. Just use a concurrent hashmap to prevent duplicates. Make sure to declare boundary int and the hashmap as final.

Try this:

import java.util.concurrent.ThreadLocalRandom;
import java.util.*;
import java.util.concurrent.*;


public class Main {
    final static int low = 0;
    final static int up = 5;
    final static Set < Integer > inthashmap = ConcurrentHashMap.newKeySet();
    
    // threadhashmap is needed to track down all threads generating ints
    final static Set < Thread > threadhashmap = ConcurrentHashMap.newKeySet();

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < up - low + 1; i++) {
            Thread t = new Thread() {
                public void run() {
                    int randomNum;
                    try {
                        randomNum = ThreadLocalRandom.current().nextInt(low, up + 1);
                        inthashmap.add(randomNum);
                        System.out.println("A new random int generated : " + randomNum);
                    } finally {

                    }
                }
            };
            threadhashmap.add(t);
            t.start();
        }
        
        //by iterating through all threads in threadhashmap
        // and joining them we guarantee that all threads were completed
        // before we print the results of work of those threads (i.e. ints)
        Iterator<Thread> iterator = threadhashmap.iterator();

        while (iterator.hasNext())
            iterator.next().join();

        System.out.println("Unique ints from hashmap:");
        inthashmap.forEach(System.out::println);
    }
}

Output:

A new random int generated : 2
A new random int generated : 3
A new random int generated : 3
A new random int generated : 0
A new random int generated : 0
A new random int generated : 2
Unique ints from hashmap:
0
2
3