Question

我需要并行运行两个线程。

1）PrimeThread计算从1到100的素数。 2）evenThread计算从1到100的偶数。

我实现了素数和均衡的逻辑。不要专注于它。我的问题是，

我想以下列方式打印数字。 10个素数 10个平均值 10个素数 10个平均值其余的。

这可能吗???

我使用了sleep（）方法，但它不起作用。请帮我。感谢。

Answer 1

我需要并行运行两个线程   [...]
  我想以下列方式打印数字。 10个素数10个均数10个素数10个均数和其余部分。

这似乎是矛盾的：你想要的输出意味着你真正想要的是按顺序运行任务，但是以交错的方式运行。为什么不创建2个方法：printNextPrimes(int number)和printNextEvens(int number)并在单个线程循环中调用它们：

for (int i = 0; i < 10; i++) {
    printNextPrimes(10);
    printNextEvens(10);
}

Answer 2

听起来你正在寻找Semaphore

每个线程都有自己的信号量。输出10个数字后，它将释放另一个线程拥有的信号量，并获得自己的信号量。这将使另一个线程再次启动，并阻止该线程直到它再次被释放。

Answer 3

这样的事情：

public class Test {
    static Object lock = new Object();
    static boolean printPrime = true;
    static boolean printEven;

    static class PrimeTread extends Thread {
        public void run() {
            int n = 0;
            while (n < 100) {
                synchronized (lock) {
                    if (printPrime) {
                        for (int i = 0; i < 10; i++) {
                            System.out.println(nextPrime());
                            n++;
                        }
                        printPrime = false;
                        printEven = true;
                        lock.notifyAll();
                    } else {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                }
            }
        }

        private int nextPrime() {
            return 31;
        }
    }

    static class EvenTread extends Thread {
        public void run() {
            int n = 0;
            while (n < 100) {
                synchronized (lock) {
                    if (printEven) {
                        for (int i = 0; i < 10; i++) {
                            System.out.println(nextEven());
                            n++;
                        }
                        printPrime = true;
                        printEven = false;
                        lock.notifyAll();
                    } else {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                }
            }
        }

        private int nextEven() {
            return 2;
        }
    }

    public static void main(String[] args) {
        new EvenTread().start();
        new PrimeTread().start();
    }
}

Answer 4

看一下这个例子，它向你展示了如何使用同步方式的线程......

在此我将打印“A，A，A，...... B，B，B ...... C，C，C”＆amp; VICE VERSA INSTEAD of RANDMOLY“C，B，A，B，C，A，B”等......

//Use of synchronize

class A
{
    char c[] = {'A', 'B', 'C'};

    synchronized void show (int index)
    {
        try
        {
            for(int i=0; i<3; i++)
            {
                System.out.println(c[index]);
                Thread.sleep(1000);
            }
        }
        catch(Exception e)
        {
            System.out.println(e);
        }
    }
}

class B extends Thread
{
    int index;
    A ob1;

    void set (int i)
    {
        index =i;
    }

    public void run()
    {
        ob1.show(index);
    }

    public static void main (String[] args)
    {
        A ob2 = new A ();

        B b1 = new B ();
        B b2 = new B ();
        B b3 = new B ();

        b1.set(0);
        b2.set(1);
        b3.set(2);

        b1.ob1 = ob2;
        b2.ob1 = ob2;
        b3.ob1 = ob2;

        b1.start();
        b2.start();
        b3.start();
    }
}

我希望这个例子对你有帮助，因为它与你的问题非常相似......

以同步方式运行线程

4 个答案: