java使用多线程找出最大随机数

找出最大随机数这一问题可以使用多线程来优化程序的效率和性能。Java提供了多种实现多线程的方法，本文将介绍如何使用Java多线程来寻找最大随机数。

1.使用Runnable接口

使用Runnable接口是实现多线程的最简单方法之一。Java中的Runnable接口定义了一个run()方法，当线程启动时该方法会被执行。我们可以通过实现Runnable接口并实现run()方法来实现多线程。下面是一个简单的例子：

public class MaxNumberRunnable implements Runnable {
    private List<Integer> numbers;

    public MaxNumberRunnable(List<Integer> numbers) {
        this.numbers = numbers;
    }

    @Override
    public void run() {
        int max = numbers.get(0);
        for (int i = 1; i < numbers.size(); i++) {
            if (numbers.get(i) > max) {
                max = numbers.get(i);
            }
        }
        System.out.println("Max Number: " + max);
    }
}

在这个例子中，MaxNumberRunnable实现了Runnable接口并定义了一个构造函数和run()方法。该类接收一个List类型的参数，该参数包含了我们需要寻找最大随机数的数列。

在run()方法中，我们通过遍历整个数列，找到其中最大的数，并使用System.out.println()方法将其输出到控制台。

现在我们可以使用这个Runnable接口来创建多个线程，并让它们同时寻找最大随机数。下面是一个示例的代码：

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        Random random = new Random();
        for (int i = 0; i < 1000000; i++) {
            numbers.add(random.nextInt(1000000));
        }

        for (int i = 0; i < 10; i++) {
            MaxNumberRunnable maxNumberRunnable = new MaxNumberRunnable(numbers);
            new Thread(maxNumberRunnable).start();
        }
    }
}

在这个示例中，我们首先生成了一个包含1000000个随机数的数组，然后创建了10个线程，每个线程都使用同一个数列来查找最大值。可以看到，每个线程都会打印出匹配的最大值，但这些线程的顺序是不同的，因为他们是在不同的线程中独立运行的。

2.使用Callable接口和Future对象

除了实现Runnable接口外，Java中还提供了使用Callable接口来实现多线程的方式。Callable接口也有一个call()方法，与Runnable接口的run()方法相似，但Callable接口的call()方法可以有返回值，并且可以抛出异常。

在这个例子中，我们将使用Callable接口和Future对象来寻找最大随机数。Future对象表示异步计算的结果。在多线程环境下使用Future对象，可以让主线程和子线程进行异步通信。

下面是一个示例代码：

public class MaxNumberCallable implements Callable<Integer> {
    private List<Integer> numbers;

    public MaxNumberCallable(List<Integer> numbers) {
        this.numbers = numbers;
    }

    @Override
    public Integer call() throws Exception {
        int max = numbers.get(0);
        for (int i = 1; i < numbers.size(); i++) {
            if (numbers.get(i) > max) {
                max = numbers.get(i);
            }
        }
        return max;
    }
}

在这个例子中，与Runnable接口不同的是，MaxNumberCallable实现了Callable接口，并且call()方法返回了一个整数，即查找到的最大随机数。

现在我们可以使用Future对象来等待子线程返回的结果，并在需要时获取结果。下面是示例程序代码：

public class Main {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        List<Integer> numbers = new ArrayList<>();
        Random random = new Random();
        for (int i = 0; i < 1000000; i++) {
            numbers.add(random.nextInt(1000000));
        }

        List<Callable<Integer>> callableList = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            callableList.add(new MaxNumberCallable(numbers));
        }

        ExecutorService executorService = Executors.newFixedThreadPool(10);
        List<Future<Integer>> futures = executorService.invokeAll(callableList);

        int max = Integer.MIN_VALUE;
        for (Future<Integer> future : futures) {
            if (future.get() > max) {
                max = future.get();
            }
        }
        System.out.println("Max Number: " + max);
        executorService.shutdown();
    }
}

在这个示例中，我们首先创建了一个包含1000000个随机数的数列，并将其传递给MaxNumberCallable类构造函数。

然后，我们创建了一个包含10个MaxNumberCallable对象的List，并使用ThreadPoolExecutor类创建了一个包含10个线程的线程池。

使用ExecutorService的invokeAll方法将callableList中的所有对象提交给线程池执行，并返回一个包含Future对象的列表。 Future对象表示异步计算的结果。

之后在主线程中遍历Future列表并等待子线程返回结果。在找到所有Future对象的最大值时，将其输出到控制台。

可以看到，使用Callable接口和Future对象的方式比使用Runnable接口更加灵活和强大。在实际的开发中，我们应该根据实际情况选择合适的线程实现方式。