java - 以同步方式运行线程

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

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

在此我将打印 "A,A,A,.....B,B,B....C,C,C" & VICE VERSA 而不是 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();
    }
}

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

Answer 3

听起来您正在寻找信号量

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

Answer 4

像这样的东西：

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();
    }
}