创建两个线程分别交替输出奇数和偶数 不输出星号一直输出 用java编写

### 回答1：

可以使用Java来创建两个线程分别交替输出奇数和偶数，不输出星号一直输出，可以这样做：1. 创建一个类，它实现Runnable接口，该接口定义了一个run（）方法，该方法将被线程调用；2. 为run（）方法编写代码，用来交替输出奇数和偶数，不输出星号一直输出；3. 创建两个线程，并将创建的类的实例作为参数传递给它们；4. 启动线程，线程将调用run（）方法，并交替输出奇数和偶数，不输出星号一直输出。

### 回答2：
下面是用Java编写的实现代码，其中使用了两个线程分别交替输出奇数和偶数，并且不输出星号。

public class OddEvenPrinter {
    private int limit;
    private volatile boolean isOddPrinting = true;

    public OddEvenPrinter(int limit) {
        this.limit = limit;
    }

    public static void main(String[] args) {
        int limit = 100;

        OddEvenPrinter printer = new OddEvenPrinter(limit);

        Thread oddThread = new Thread(() -> {
            for (int i = 1; i <= limit; i += 2) {
                synchronized (printer) {
                    while (!printer.isOddPrinting) {
                        try {
                            printer.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println(i);
                    printer.isOddPrinting = false;
                    printer.notifyAll();
                }
            }
        });

        Thread evenThread = new Thread(() -> {
            for (int i = 2; i <= limit; i += 2) {
                synchronized (printer) {
                    while (printer.isOddPrinting) {
                        try {
                            printer.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println(i);
                    printer.isOddPrinting = true;
                    printer.notifyAll();
                }
            }
        });

        oddThread.start();
        evenThread.start();
    }
}

这个程序创建了两个线程，oddThread用于输出奇数，evenThread用于输出偶数。通过一个共享的标志位isOddPrinting来控制两个线程的交替输出。

其中使用了synchronized关键字来保证线程同步。每个线程在输出一个数字后，都会调用notifyAll()方法来唤醒等待的线程，然后自己等待，直到被唤醒再继续执行。同时，使用while循环来防止虚假唤醒（spurious wake-ups）的情况发生。

这样，oddThread和evenThread就可以交替输出奇数和偶数，直到达到限制的数字个数。

### 回答3：
以下是一个用Java编写的程序，利用两个线程交替输出奇数和偶数：

public class OddEvenPrinter {
    private static volatile int counter = 1;
    private static final Object lock = new Object();
    
    public static void main(String[] args) {
        Thread oddThread = new Thread(OddEvenPrinter::printOdd);
        Thread evenThread = new Thread(OddEvenPrinter::printEven);
        
        oddThread.start();
        evenThread.start();
    }
    
    public static void printOdd() {
        while (true) {
            synchronized (lock) {
                if (counter % 2 != 0) {
                    System.out.println(counter);
                    counter++;
                    lock.notify();
                } else {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    
    public static void printEven() {
        while (true) {
            synchronized (lock) {
                if (counter % 2 == 0) {
                    System.out.println(counter);
                    counter++;
                    lock.notify();
                } else {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

这个程序中，我们使用一个共享的`counter`变量来记录当前应该输出的数字，初始为1。使用`synchronized`关键字保证了两个线程的互斥访问，而`wait()`和`notify()`方法用于实现线程的等待和唤醒。每个线程在输出一个数字后，会调用`wait()`方法等待另一个线程的通知。当另一个线程输出完毕后，会调用`notify()`方法唤醒等待的线程，使其继续执行。

注意：为了控制输出长度，这里的程序并没有加入退出条件，需要手动终止程序的运行。