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

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

需求

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

非多线程下的随机数获取

实现获取随机数的方式两种:
– 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 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 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 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 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 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。

总结

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

你可能感兴趣的:(并发学习,多线程,并发,java)