Java方法同步 import java.util.logging.Level； 导入java.util.logging.Logger； 公开课考试{ 专用静态无效m1（最终字符串a）{ 线程t1=新线程（新的可运行线程（）{ @凌驾 公开募捐{ 试一试{ 睡眠（1000）； 系统输出打印（a）； }捕获（中断异常例外）{ Logger.getLogger（test.class.getName（））.log（Level.SEVERE， 零，ex）； } } }); t1.start（）； } 专用静态空隙m2（最终字符串a）{ 线程t2=新线程（新可运行（）{ @凌驾 公开募捐{ 试一试{ 睡眠（1000）； 系统输出打印（“+a”）； }捕获（中断异常例外）{ Logger.getLogger（test.class.getName（））.log（Level.SEVERE， 零，ex）； } } }); t2.start（）； } 公共静态void main（字符串[]args）{ 对于（int i=0；i

我想得到输出 米希赫鲁布 MihiCherub同样做了10次

---

但现在我的输出是“MihiMihi Cherub CherubMihi CherubMihi”。我想同步我的两个方法，并希望得到结果作为mihicherub。请帮助..

如果要同步行为，最好使用一个线程

线程是为相对独立的任务设计的，越独立越好

通过同步、等待和通知，您可以做您想做的事情，但这将相对复杂（而且毫无意义）

---

在您的情况下，

println（“”）

将在任何其他print（）之前执行。这是有意的吗？

使用

倒计时闩锁

可以实现这一点，但这不是一种有效的方法。我已经修改了你的代码如下

import java.util.logging.Level;
import java.util.logging.Logger;


public class test {

    private static void m1(final String a) {
        Thread t1 = new Thread(new Runnable() {

                @Override
                public void run() {
                    try {
                        Thread.sleep(1000);
                        System.out.print(a);
                    } catch (InterruptedException ex) {
                        Logger.getLogger(test.class.getName()).log(Level.SEVERE,
                                                                   null, ex);
                    }
                }
            });
        t1.start();
    }

    private static void m2(final String a) {
        Thread t2 = new Thread(new Runnable() {

                @Override
                public void run() {
                    try {
                        Thread.sleep(1000);
                        System.out.print(" " + a);
                    } catch (InterruptedException ex) {
                        Logger.getLogger(test.class.getName()).log(Level.SEVERE,
                                                                   null, ex);
                    }
                }
            });
        t2.start();
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            m1("Mihi");
            m2("Cherub");
            System.out.println("");
        }
    }
}

---

对我来说就像是一个家庭作业，只是关于同步逻辑。然而，这个例子确实不太合适，最好先看看生产者/消费者，他们更容易理解和理解！如果这是

[家庭作业]

，请这样标记，那么我们将知道您无法更改要求，即使它们没有意义。；）在您的例子中，您可以在

t1.start（）

和

t2.start（）之后分别添加
t1.join（）
和
t2.start（）
import java.util.concurrent.CountDownLatch;
import java.util.logging.Level;
import java.util.logging.Logger;

public class test {

private static void m1(final String a, final CountDownLatch sharedCountDownLatch,
        final CountDownLatch masterCountDownLatch,
        final CountDownLatch doneCountDownLatch) {
    Thread t1 = new Thread(new Runnable() {

        @Override
        public void run() {
            try {
                sharedCountDownLatch.countDown();
                sharedCountDownLatch.await();
                System.out.print(a);
                masterCountDownLatch.countDown();

            } catch (InterruptedException ex) {
                Logger.getLogger(test.class.getName()).log(Level.SEVERE,
                        null, ex);
            } finally {
                doneCountDownLatch.countDown();
            }
        }
    });
    t1.start();
}

private static void m2(final String a, final CountDownLatch sharedCountDownLatch,
        final CountDownLatch masterCountDownLatch,
        final CountDownLatch doneCountDownLatch) {
    Thread t2 = new Thread(new Runnable() {

        @Override
        public void run() {
            try {
                sharedCountDownLatch.countDown();
                sharedCountDownLatch.await();
                masterCountDownLatch.await();
                System.out.print(" " + a + " ");
            } catch (InterruptedException ex) {
                Logger.getLogger(test.class.getName()).log(Level.SEVERE,
                        null, ex);
            } finally {
                doneCountDownLatch.countDown();
            }
        }
    });
    t2.start();
}

public static void main(String[] args) throws InterruptedException {
    for (int i = 0; i < 10; i++) {
        CountDownLatch doneCountDownLatch = new CountDownLatch(2);//CountDownLatch which will be to ensure that both threads executed.
        CountDownLatch sharedCountDownLatch = new CountDownLatch(2);//CountDownLatch that will be shared between both threads so that it will ensure that both threads are at the same execution point 
        CountDownLatch masterCountDownLatch = new CountDownLatch(1);//CountDownLatch which will be used when master thread completes it work
        m1("Mihi", sharedCountDownLatch, masterCountDownLatch,
                doneCountDownLatch);
        m2("Cherub", sharedCountDownLatch, masterCountDownLatch,
                doneCountDownLatch);
        System.out.println("");
        doneCountDownLatch.await();
    }
}
}

Mihi Cherub 
Mihi Cherub 
Mihi Cherub 
Mihi Cherub 
Mihi Cherub 
Mihi Cherub 
Mihi Cherub 
Mihi Cherub 
Mihi Cherub 
Mihi Cherub