Question

好的，所以我想生成一个随机数用于在线程中打印。一个和两个工作正常，但三个只打印出相同的随机数。因此，如果一个生成1928年，它会一次又一次地睡到1928年。如何制作动态随机数？如果另一个随机数（num）小于1000，则我想要中断的唯一一个。

package thread;

import java.util.Random;

public class Threads {

public static Thread one;
public static Thread two;
public static Thread three;

public static int numbers[] = { 1, 2, 3, 4, 5 };
public static String letters[] = { "a", "b", "c", "d", "e" };
public static float negatives[] = { -1, -2, -3, -4, -5 };
public static Random rand = new Random();

public static void main(String args[]) {
    startSequences();
    one.setName("one");
    two.setName("two");
    three.setName("three");
    one.start();
    two.start();
    three.start();
}

public static void startSequences() {
    one = new Thread() {
        public void run() {
            try {
                System.out
                        .println("Numbers\n-----------------------------------");
                for (int i = 0; i < numbers.length; i++) {
                    int a = rand.nextInt(3999);
                    System.out.printf(
                            "%s is sleeping for %d milliseconds. \n",
                            Thread.currentThread().getName(), a);
                    Thread.sleep(a);
                    System.out.println(Thread.currentThread().getName()
                            + " is done sleeping.");
                    System.out.printf("current number is %s\n", numbers[i]);
                }

            } catch (InterruptedException e) {
                System.out.printf("%s has been interrupted. How rude!",
                        Thread.currentThread().getName());
            } finally {
                System.out.printf("%s is finally done!\n", Thread
                        .currentThread().getName());
            }
        }
    };

    two = new Thread() {
        public void run() {
            try {
                one.join();
                System.out
                        .println("\nLetters\n-----------------------------------");
                for (int i = 0; i < letters.length; i++) {
                    int a = rand.nextInt(3999);
                    System.out.printf(
                            "%s is sleeping for %d milliseconds.\n", Thread
                                    .currentThread().getName(), a);
                    Thread.sleep(a);
                    System.out.println(Thread.currentThread().getName()
                            + " is done sleeping.");
                    System.out.printf("current letter is %s\n", letters[i]);
                }
            } catch (InterruptedException e) {
                System.out.printf("%s has been interrupted. How rude!",
                        Thread.currentThread().getName());
            } finally {
                System.out.printf("%s is now done. Finally!", Thread
                        .currentThread().getName());
            }
        }
    };

    three = new Thread() {
        public void run() {
            try {
                int num = rand.nextInt(3999);
                two.join();
                if (num < 1000) {
                    System.out
                            .printf("\n%s is being interrupted because the random was %d and lower than 1000.",
                                    Thread.currentThread().getName(), num);
                    Thread.sleep(2000);
                    Thread.currentThread().interrupt();
                } else {
                    int a = rand.nextInt(3999);
                    System.out
                            .println("\nNegatives-----------------------------------\n");
                    System.out
                            .printf("the number was %s, Therefore, it will not be interrupted.",
                                    num);
                    for (int i = 0; i < negatives.length; i++) {
                        System.out.printf(
                                "\n%s is sleeping for %d milliseconds.",
                                Thread.currentThread().getName(), a);
                        Thread.sleep(a);
                        System.out.printf("\n%s has finished sleeping.",
                                Thread.currentThread().getName());
                        System.out.printf(
                                "\ncurrent negative number is %s",
                                negatives[i]);
                    }
                }
            } catch (InterruptedException e) {
                System.out.printf("\n%s has been interrupted. How rude!",
                        Thread.currentThread().getName());
            } finally {
                System.out.printf("\n%s is now done. Finally!", Thread
                        .currentThread().getName());
            }
        }
    };
}

}

Answer 1

如果我理解你的问题，那么对于Thread three，你需要将随机数生成移动到循环中。像，

// int a = rand.nextInt(3999);
System.out.println("\nNegatives-----------------------------------");
System.out.printf("the number was %s and will not be interrupted.%n", num);
for (int i = 0; i < negatives.length; i++) {
    int a = rand.nextInt(3999);

Answer 2

没有测试，我只是检查了Random的javadoc。我找到了：

java.util.Random的实例是线程安全的。但是，跨线程并发使用相同的java.util.Random实例可能会遇到争用并因此导致性能不佳。请考虑在多线程设计中使用ThreadLocalRandom。

所以你可以查看ThreadLocalRandom，如果它解决了你的问题。

Java线程随机

2 个答案: