Java 使用Thread.run（）在增强循环中同时执行两个线程

例外O/p:

public abstract class Multithread implements Runnable{
    static Thread t1 = new Thread(){
        public  synchronized void run(){
            try {
                for(;;){
                    System.out.println("java");
                    t1.sleep(300);
                }
            } catch (Exception e) {
                System.out.println("Exception"+e);
            }
        }
    };
    static Thread t2 = new Thread(){
        public  synchronized void  run(){
            try{
                for(;;){
                    System.out.println("world");
                    t2.sleep(300);
                }
            }catch(Exception e){
                System.out.println("Exception"+e);
            }
        }
    };
    public static void main(String[] args) {
        try{
            t1.start();
            t2.start();
        }catch(Exception e){
            System.out.println("Exception "+e);
        }
    }
    @Override
    public void run() {
        System.out.println("running");
    }
}

观察到的 我尝试对线程使用sleep（），它们在某个时间点会像这样重叠-

java
world
java
world
java
world
.
.
.
.

预期的

---

我需要这两个线程并行运行，它不应该重叠，任何一个线程都可以启动。有什么想法吗？

线程在时间上不准确。如果它们相互依赖，则必须手动同步，例如：

您可以通过使用计数器来实现这一点，如果计数器为0，则线程1执行、递增计数器并调用计数器上的NotyYall（），如果计数器为1，则线程1调用计数器上的wait（）。线程2也是如此。

当您并行执行两个线程时，它们中的每一个都由底层操作系统独立执行。任务调度器可以决定何时执行哪个线程。这可能会导致不均匀的时间分布，就像您正在经历的那样

一种解决方案是使用共享线程锁定每个线程，直到另一个线程完成其任务。然后，每个线程将接收两个信号量，一个用于自身，另一个用于另一个线程。两个信号量都以一个许可证开始，因此第一个

release（）

调用不会阻塞。然后线程将像这样工作（psudocode）：

---

另一种方法是将无限循环移出线程。在循环的每次迭代中，您都会生成两个线程，然后使用thread.yield（）等待两个线程完成，然后循环再次开始创建两个新线程。但是请注意，创建线程可能是一项昂贵的操作，因此您应该仅在线程在每次迭代中执行大量工作时才执行此操作，这样就不太重要了。

在您的示例中使用“synchronized”是不正确的。您需要将两个类方法声明为synchronized，而不是Thread类的委托。如果您阅读过任何java线程文档/javadoc，您会想到什么？

java
java
world
java
world
world 
java 
..

for (;;) {
    otherThreadSemaphore.acquire(); // blocks until the other thread called release()
    performWork();
    ownThreadSemaphore.release(); // allows the other thread to perform another iteration
}