编写一个应用程序创建两个线程，一个线程打印输出1～1000之间所有的奇数，另外一个线程打印输出1～1000之间所有的偶数，要求两个线程随机休眠一段时间后继续打印输出下一个数。分别使用runnable接

### 回答1：
口和继承Thread类两种方式实现。

使用Runnable接口实现：

public class PrintNumber implements Runnable {
    private int start;
    private int end;
    private boolean isOdd;

    public PrintNumber(int start, int end, boolean isOdd) {
        this.start = start;
        this.end = end;
        this.isOdd = isOdd;
    }

    @Override
    public void run() {
        for (int i = start; i <= end; i++) {
            if ((i % 2 ==  && !isOdd) || (i % 2 == 1 && isOdd)) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
            try {
                Thread.sleep((long) (Math.random() * 100));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        PrintNumber odd = new PrintNumber(1, 100, true);
        PrintNumber even = new PrintNumber(1, 100, false);

        Thread t1 = new Thread(odd, "Odd");
        Thread t2 = new Thread(even, "Even");

        t1.start();
        t2.start();
    }
}

使用继承Thread类实现：

public class PrintNumber extends Thread {
    private int start;
    private int end;
    private boolean isOdd;

    public PrintNumber(int start, int end, boolean isOdd) {
        this.start = start;
        this.end = end;
        this.isOdd = isOdd;
    }

    @Override
    public void run() {
        for (int i = start; i <= end; i++) {
            if ((i % 2 ==  && !isOdd) || (i % 2 == 1 && isOdd)) {
                System.out.println(getName() + ": " + i);
            }
            try {
                sleep((long) (Math.random() * 100));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        PrintNumber odd = new PrintNumber(1, 100, true);
        PrintNumber even = new PrintNumber(1, 100, false);

        odd.setName("Odd");
        even.setName("Even");

        odd.start();
        even.start();
    }
}

### 回答2：
在Java中，我们可以使用Thread类或Runnable接口来创建多线程应用程序。在本题中，我们使用Runnable接口创建两个线程，一个线程负责打印奇数，另一个线程负责打印偶数。

下面是实现这个应用程序的步骤：

步骤1：创建实现Runnable接口的OddEvenPrinter类。

class OddEvenPrinter implements Runnable {
    private int max;
    private boolean isEvenNumber;
    private Printer printer;

    public OddEvenPrinter(int max, boolean isEvenNumber, Printer printer) {
        this.max = max;
        this.isEvenNumber = isEvenNumber;
        this.printer = printer;
    }

    @Override
    public void run() {
        int number = isEvenNumber ? 2 : 1;
        while (number <= max) {
            if (isEvenNumber) {
                printer.printEven(number);
            } else {
                printer.printOdd(number);
            }
            number += 2;
            try {
                Thread.sleep((long) (Math.random() * 1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

在这个类中，我们定义了一个max变量表示打印的最大值，一个isEvenNumber变量表示是否打印偶数，一个printer变量表示打印机。在run方法中，我们使用while循环打印所有满足条件的数字，然后使用Thread.sleep方法随机休眠一段时间。

步骤2：创建一个Printer类，用来打印数字。

class Printer {
    private boolean isOddPrinted = false;

    synchronized void printOdd(int number) {
        while (isOddPrinted) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("Odd: " + number);
        isOddPrinted = true;
        notify();
    }

    synchronized void printEven(int number) {
        while (!isOddPrinted) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("Even: " + number);
        isOddPrinted = false;
        notify();
    }
}

在这个类中，我们定义了一个isOddPrinted变量表示打印的数字是否为奇数。printOdd方法用来打印奇数，printEven方法用来打印偶数。在这两个方法中，我们使用了synchronized关键字来保证线程安全，在打印完一个数字后，使用notify方法唤醒等待的线程，并设置isOddPrinted变量的值。

步骤3：创建Test类，并在main方法中启动两个线程来打印奇数和偶数。

public class Test {
    public static void main(String[] args) {
        Printer printer = new Printer();
        Thread t1 = new Thread(new OddEvenPrinter(1000, false, printer));
        Thread t2 = new Thread(new OddEvenPrinter(1000, true, printer));
        t1.start();
        t2.start();
    }
}

在这个类中，我们创建了一个Printer对象和两个线程，分别用来打印奇数和偶数。然后，我们调用线程的start方法启动线程。此时，两个线程将随机休眠一段时间后继续打印输出下一个数字，直到打印完所有的数字。

综上所述，我们可以通过实现Runnable接口来创建多线程应用程序，来打印1到1000之间的奇数和偶数。这个应用程序使用了线程间的通信来保证打印奇数和偶数的顺序正确。

### 回答3：
题目要求我们创建两个线程，分别打印输出1~1000之间的奇数和偶数。为了实现这一功能，我们可以使用Java语言中的多线程技术，使用runnable接口编写程序。

首先我们需要定义两个类，分别用来表示奇数线程和偶数线程。为了实现线程的随机休眠，我们在每次输出之后让线程sleep一个随机的时间：

class OddThread implements Runnable {

    @Override
    public void run() {
        for (int i = 1; i <= 1000; i += 2) {
            System.out.println("Odd Thread: " + i);
            try {
                Thread.sleep((int)(Math.random()*100));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

class EvenThread implements Runnable {

    @Override
    public void run() {
        for (int i = 2; i <= 1000; i += 2) {
            System.out.println("Even Thread: " + i);
            try {
                Thread.sleep((int)(Math.random()*100));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

上述代码中，OddThread用来打印奇数，EvenThread用来打印偶数，每次输出之后都随机休眠一段时间。

我们再来看看如何启动这两个线程。我们可以在主函数中分别创建两个线程，并将其交给Thread类来启动：

public class Main {

    public static void main(String[] args) {
        
        // 创建两个线程
        Thread oddThread = new Thread(new OddThread());
        Thread evenThread = new Thread(new EvenThread());
        
        // 启动线程
        oddThread.start();
        evenThread.start();
        
    }

}

上述代码中，我们首先创建了两个线程，在创建线程时需要传入对应的Runnable实例。然后我们通过调用start()方法启动两个线程，线程就会开始执行。

最后，我们就可以运行程序来验证一下我们的代码是否正确。运行结果如下：

Even Thread: 2
Odd Thread: 1
Even Thread: 4
Odd Thread: 3
Even Thread: 6
Odd Thread: 5
...

由于线程每次随机休眠一段时间，因此打印输出的顺序并不一定是按照顺序来的，但是奇数和偶数的输出都是正确的。

综上所述，本题要求我们使用Java多线程技术编写一个应用程序，创建两个线程分别输出1~1000之间的奇数和偶数，两个线程还需要随机休眠一段时间后继续输出下一个数字。我们可以使用runnable接口来实现这个功能，主要代码见上。