多线程基础学习九：练习-多线程获取不重复的随机数字

「爱情、让人受尽委屈。」 2022-06-05 03:49 235阅读 0赞

今天在联系一下前面学习的知识，实现一个简单的需求。

### 需求 ###

多个线程并发获取随机数，要求随机数据不能重复。

### 非多线程下的随机数获取 ###

实现获取随机数的方式两种：  
– Math.random()  
– new Random.nextInt(int)

因为一般获取随机数都要求是整数，所以第一种获取方式一般需要乘以10的n次方，所以这次练习采用第二种方式。

测试代码：

public static void main (String[] args) {
    
            Random random = new Random();
    
            for (int i = 0; i < 10; i++) {
                System.out.println(random.nextInt(10));
            }
        }

执行结果：

4
    3
    5
    2
    3
    8
    3
    2
    0
    9

在限制了随机数范围的情况下（< 10），获取10次，多次出现重复数据。

为了解决这个问题，我要引入一个变量用来存储已出现的随机数，判断随机数是否已经出现，出现就重新生成。  
修改代码：

static  Map<String, String> map = new HashMap<>();
     public static void main (String[] args) {
    
            Random random = new Random();
            int num;
            for (int i = 0; i < 10; i++) {
                num = random.nextInt(10);
                num = createUnRepetNum(num, random);
                System.out.println(num);
            }
        }
    
        private static int createUnRepetNum(int num, Random random) {
    
            String value = map.get(String.valueOf("key" + num));
            if (null != value) {
                num = random.nextInt(10);
                num = createUnRepetNum(num, random);
            } else {
                map.put("key" + num, "");
            }
            return num;
        }

执行结果：

7
    4
    0
    8
    9
    3
    5
    1
    6
    2

这样的话，通过额外的变量，保证了生成的数据的不重复。（这只是一种方式，还有其它实现方式）

### 多线程的情况下的随机数获取 ###

**在上面不重复获取的基础，增加多线程。**

static  Map<String, String> map = new HashMap<>();
    
        public static void main (String[] args) {
    
            Random random = new Random();
    
            for (int i = 0; i < 10; i++) {
                new Thread(new Runnable() {
                    @Override
                    public void run () {
                        int num = random.nextInt(10);
                        num = createUnRepetNum(num, random);
                        System.out.println(num);
                    }
                }).start();
            }
        }
    
        private static int createUnRepetNum(int num, Random random) {
    
            String value = map.get(String.valueOf("key" + num));
            if (null != value) {
                num = random.nextInt(10);
                num = createUnRepetNum(num, random);
            } else {
                map.put("key" + num, "");
            }
            return num;
        }

执行结果：

1
    4
    3
    7
    9
    5
    6
    0
    2
    2

这是我执行几十次才得到一个错误结果，基本上都是正确结果。  
出现了错误结果，就说明上面的代码不正确。

根据前面的学习，我知道是因为map的原因，在多线程的情况下出现了读写数据不一致的情况，所以解决这个重复数据问题，实际上就是解决map的同步问题。

前面学过volatile这个同步关键字可以保证读取的最新的，不能保证写数据的正确性，所以尝试把用volatile和synchronized，保证数据的准确性。

synchronized：

static   Map<String, String> map = new HashMap<>();
    
        public static void main (String[] args) {
    
            Random random = new Random();
    
            for (int i = 0; i < 10; i++) {
                new Thread(new Runnable() {
                    @Override
                    public void run () {
                        int num = random.nextInt(10);
                        num = createUnRepetNum(num, random);
                        System.out.println(num);
                    }
                }).start();
            }
        }
    
        private static synchronized int createUnRepetNum(int num, Random random) {
    
            String value = map.get(String.valueOf("key" + num));
            if (null != value) {
                num = random.nextInt(10);
                num = createUnRepetNum(num, random);
            } else {
                map.put("key" + num, "");
            }
            return num;
        }

这样会使线程逐一执行，结果一定是对，但是效率非常低。

**实际上我还尝试了一种写法（经验证实际上错误的）**：

static volatile   Map<String, String> map = new HashMap<>();
    
        public static void main (String[] args) {
    
            Random random = new Random();
    
            for (int i = 0; i < 10; i++) {
                new Thread(new Runnable() {
                    @Override
                    public void run () {
                        int num = random.nextInt(10);
                        num = createUnRepetNum(num, random);
                        System.out.println(num);
                    }
                }).start();
            }
        }
    
        private static int createUnRepetNum(int num, Random random) {
    
            String value = map.get(String.valueOf("key" + num));
            if (null != value) {
                num = random.nextInt(10);
                num = createUnRepetNum(num, random);
            } else {
                synchronized (GetNoRepNum.class) {
                    map.put("key" + num, "");
                }
            }
            return num;
        }

这种写法经过验证，确认是错误，主要是因为有可能线程取到了随机数据（其它线程已取到，但是还没有放到map中（阻塞在存放数据的地方了）），这是判断就会出错，出现重复数据。

**使用线程安全类实现**  
ConcurrentHashMap：

static   Map<String, String> map = new ConcurrentHashMap<>();
    
        public static void main (String[] args) {
    
            Random random = new Random();
    
            for (int i = 0; i < 10; i++) {
                new Thread(new Runnable() {
                    @Override
                    public void run () {
                        int num = random.nextInt(10);
                        num = createUnRepetNum(num, random);
                        System.out.println(num);
                    }
                }).start();
            }
        }
    
        private static int createUnRepetNum(int num, Random random) {
    
            String value = map.get(String.valueOf("key" + num));
            if (null != value) {
                num = random.nextInt(10);
                num = createUnRepetNum(num, random);
            } else {
                map.put("key" + num, "");
            }
            return num;
        }

因为是线程安全类，我又执行了几十次，都没有出现错误结果，这种写法应该也是正确的。

还有一个线程安全类Hashtable，和上面写法类似，应该也是正确的，不过网上说这个Hashtable类效率较差，不如ConcurrentHashMap。

### 总结 ###

这次结合前面学习的知识实现了一个简单多线程获取随机数的需求，继续学习，希望以后可以实现结合数据库操作的简单抽奖需求。