Java 以同步方式运行线程

我需要并行运行两个线程

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

我实现了素数和偶数的逻辑。不要把注意力集中在它上面。 我的问题是,

我想用以下方式打印数字。 10素数 10晚 10素数 10晚 还有其他人

有可能吗

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

---

谢谢。

听起来你好像在找一份工作

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

类似于以下内容：

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

公共类测试{
静态对象锁=新对象（）；
静态布尔printPrime=true；
静态布尔偶数；
静态类PrimeTread扩展线程{
公开募捐{
int n=0；
而（n<100）{
已同步（锁定）{
if（printPrime）{
对于（int i=0；i<10；i++）{
System.out.println（nexttime（））；
n++；
}
printPrime=false；
print偶数=真；
lock.notifyAll（）；
}否则{
试一试{
lock.wait（）；
}捕捉（中断异常e）{
抛出新的运行时异常（e）；
}
}
}
}
}
private int nexttime（）{
返回31；
}
}
静态类EvenTread扩展线程{
公开募捐{
int n=0；
而（n<100）{
已同步（锁定）{
如果（打印偶数）{
对于（int i=0；i<10；i++）{
System.out.println（nextEven（））；
n++；
}
printPrime=true；
print偶数=假；
lock.notifyAll（）；
}否则{
试一试{
lock.wait（）；
}捕捉（中断异常e）{
抛出新的运行时异常（e）；
}
}
}
}
}
私有int nextEven（）{
返回2；
}
}
公共静态void main（字符串[]args）{
新建EvenTread（）.start（）；
新建PrimeTread（）.start（）；
}
}

我需要并行运行两个线程。
[…]
我想用以下方式打印数字。10个素数10个偶数10个素数10个偶数和其他素数

这似乎是矛盾的：您想要的输出意味着您真正想要的是按顺序运行任务，但以交错方式运行。为什么不创建两个方法：

printnexttime（int-number）

和

printNextEvens（int-number）

，并在单线程循环中调用它们：

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

for（int i=0；i<10；i++）{
下一次印刷（10）；
printNextEvens（10）；
}

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

在本文中，我将打印“A，A，A，…B，B，…C，C，C”&反之亦然，而不是RANDMOLY的“C，B，A，B，C，A，B”等

//使用同步
甲级
{
字符c[]={'A'，'B'，'c'}；
同步无效显示（整数索引）
{
尝试
{
对于（int i=0；iDid）您是否尝试了有关线程同步的Oracles文档？是的……但我找不到解决方案。请签出“等待并通知”，我建议稍微更改以扩展Runnable而不是thread-请参阅
//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();
    }
}