在一个线程中求100以内素数，求出后休眠一个随机时间。在另一线程中求100以内能被3整除的数，求出后休眠一个随机时间。输出数据时应有提示，指明哪个线程输出的数据。Java实现

### 回答1：
下面是一个 Java 程序的示例，它演示了如何在两个线程中分别求出 100 以内的素数和能被 3 整除的数，并且在输出结果的同时提示哪个线程输出的数据：

import java.util.Random;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // 创建两个线程
        Thread thread1 = new Thread(new PrimeThread());
        Thread thread2 = new Thread(new MultipleThread());

        // 启动两个线程
        thread1.start();
        thread2.start();
    }
}

class PrimeThread implements Runnable {
    @Override
    public void run() {
        // 求 100 以内的素数
        for (int i = 2; i <= 100; i++) {
            boolean isPrime = true;
            for (int j = 2; j < i; j++) {
                if (i % j == 0) {
                    isPrime = false;
                    break;
                }
            }
            if (isPrime) {
                System.out.println("线程 1：" + i);
            }

            // 休眠一个随机时间
            try {
                Thread.sleep(new Random().nextInt(1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class MultipleThread implements Runnable {
    @Override
    public void run() {
        // 求 100 以内能被 3 整除的数
        for (int i = 3; i <= 100; i += 3) {
            System.out.println("线程 2：" + i);

            // 休眠一个随机时间
            try {
                Thread.sleep(new Random().nextInt(1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

在这个程序中，我们创建了两个线程，分别由 `PrimeThread` 和 `MultipleThread` 类实现，并且在两个线程的 `run` 方法中分别求出 100 以内的素数和能被 3 整除的数。在

### 回答2：
Java多线程编程可以使用线程类Thread和接口Runnable来实现。我们可以创建两个线程，一个用于求100以内的素数，另一个用于求能被3整除的数。

首先，创建名为PrimeNumberThread的线程类来求100以内的素数，代码如下：

import java.util.Random;

public class PrimeNumberThread extends Thread {
    @Override
    public void run() {
        Random random = new Random();
        System.out.println("开始求素数：");

        for (int i = 2; i < 100; i++) {
            boolean isPrime = true;
            for (int j = 2; j < i; j++) {
                if (i % j == 0) {
                    isPrime = false;
                    break;
                }
            }
            if (isPrime) {
                System.out.println("素数：" + i);
            }

            try {
                Thread.sleep(random.nextInt(3000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        PrimeNumberThread thread = new PrimeNumberThread();
        thread.start();
    }
}

接下来，创建名为DivisibleByThreeThread的线程类来求100以内能被3整除的数，代码如下：

import java.util.Random;

public class DivisibleByThreeThread implements Runnable {
    @Override
    public void run() {
        Random random = new Random();
        System.out.println("开始求能被3整除的数：");

        for (int i = 1; i < 100; i++) {
            if (i % 3 == 0) {
                System.out.println("能被3整除的数：" + i);
            }

            try {
                Thread.sleep(random.nextInt(3000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Thread thread = new Thread(new DivisibleByThreeThread());
        thread.start();
    }
}

以上代码中，每次输出数据之前，线程会通过休眠一个随机时间来模拟线程的运行延迟。输出的数据中加入了哪个线程输出的提示信息。

为了让两个线程能并发执行，可以使用线程池或者使用ExecutorService来管理线程的执行。

以上代码是使用Java线程实现了在两个线程中分别求100以内的素数和能被3整除的数，并在求出数据后休眠一个随机时间输出数据，并指明哪个线程输出的数据。

### 回答3：
以下是一个使用Java多线程实现的程序，其中一个线程用于求解100以内的所有素数，另一个线程用于求解100以内能被3整除的数，并在输出数据时给出提示。

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class PrimeAndDivisibleByThree {
    public static void main(String[] args) {
        // 创建两个线程实例
        Thread primeThread = new Thread(new PrimeNumberRunnable());
        Thread divisibleByThreeThread = new Thread(new DivisibleByThreeRunnable());

        // 启动两个线程
        primeThread.start();
        divisibleByThreeThread.start();
    }

    // 判断一个数是否是素数
    public static boolean isPrime(int num) {
        if (num < 2) {
            return false;
        }
        for (int i = 2; i <= Math.sqrt(num); i++) {
            if (num % i == 0) {
                return false;
            }
        }
        return true;
    }

    // 生成指定范围内的随机整数
    public static int generateRandomNumber(int min, int max) {
        Random random = new Random();
        return random.nextInt(max - min + 1) + min;
    }

    // 线程类，用于求解100以内的素数
    static class PrimeNumberRunnable implements Runnable {

        @Override
        public void run() {
            List<Integer> primeNumbers = new ArrayList<>();

            for (int i = 0; i <= 100; i++) {
                if (isPrime(i)) {
                    primeNumbers.add(i);
                    System.out.println("素数线程输出的数据：" + i);
                    try {
                        int sleepTime = generateRandomNumber(1000, 3000); // 生成1秒到3秒之间的随机休眠时间
                        Thread.sleep(sleepTime);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }

            System.out.println("素数线程求解完毕。");
        }
    }

    // 线程类，用于求解100以内能被3整除的数
    static class DivisibleByThreeRunnable implements Runnable {

        @Override
        public void run() {
            for (int i = 0; i <= 100; i++) {
                if (i % 3 == 0) {
                    System.out.println("能被3整除线程输出的数据：" + i);
                    try {
                        int sleepTime = generateRandomNumber(1000, 3000); // 生成1秒到3秒之间的随机休眠时间
                        Thread.sleep(sleepTime);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }

            System.out.println("能被3整除线程求解完毕。");
        }
    }
}

在上述代码中，我们定义了一个`isPrime`方法来判断一个数是否是素数，以及一个`generateRandomNumber`方法来生成指定范围内的随机整数。

主程序中创建了两个线程实例，分别用于寻找素数和寻找能被3整除的数。然后启动这两个线程。

每个线程都会遍历100以内的数字，找到符合条件的数字后进行输出，并随机休眠一段时间。

注意，线程的运行是异步的，所以最终的输出结果可能是无序的。