Java 为什么这个空的同步块会影响程序的输出？

因此，当我注意到程序中显示的空synchronized块导致输出同步时，我正在处理基本并发。街区里什么都没有，为什么会这样

public class MainClass {

    public static void main(String[] args) throws InterruptedException {
        SyncTest f = new SyncTest();
        f.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("MAIN THREAD:" + i);
            Thread.sleep(500);
               synchronized (f) {
                for (int t = 0; t < 15; t++) {
                    Thread.sleep(100);
                }
            }
        }
    }
 }

public类MainClass{
公共静态void main（字符串[]args）引发InterruptedException{
SyncTest f=新的SyncTest（）；
f、 start（）；
对于（int i=0；i<20；i++）{
System.out.println（“主线程：+i”）；
睡眠（500）；
已同步（f）{
对于（int t=0；t<15；t++）{
睡眠（100）；
}
}
}
}
}

---

类SyncTest扩展线程{
@凌驾
公开募捐{
对于（int i=0；i<10；i++）{
试一试{
System.out.println（“其他线程：+i”）；
睡眠（1300）；
synchronized（this）{}//为什么在注释时这会对输出产生影响？
}catch（InterruptedException ex）{}
}
}
}

如果指定的锁已被另一个线程占用，则执行流将不会进入

已同步的

块。即使同步块根本不包含任何代码，情况也总是如此

---

示例中的锁是同一个对象（SyncTest的实例），因此当非空同步块运行时，空块将等待它完成。在这种情况下，由于

Thread.sleep（）

调用的排列方式，因此输出很可能被同步。

如果指定的锁已被另一个线程占用，则执行流将不会进入

synchronized

块。即使同步块根本不包含任何代码，情况也总是如此

---

示例中的锁是同一个对象（SyncTest的实例），因此当非空同步块运行时，空块将等待它完成。在这种情况下，由于

线程.sleep（）

调用的排列方式，因此输出很可能被同步。

同步的机制可以这样总结

synchronized(f) { //wait for no-one use f
    // do some stuff
    //nobdy can use f during this time
} //free f, other can use it

它基本上就像你用了一把锁，锁是f

---

因此，即使您的块除了等待什么都不做，在这个等待时间内，f也不可用。因此，它将同步您的程序，即使您的程序块中只有等待

同步的机制可以总结如下

synchronized(f) { //wait for no-one use f
    // do some stuff
    //nobdy can use f during this time
} //free f, other can use it

它基本上就像你用了一把锁，锁是f

---

因此，即使您的块除了等待什么都不做，在这个等待时间内，f也不可用。因此，它将同步您的程序，即使您的块中只有一个等待

您已经被同一对象同步了2次

第一次上主课：

SyncTest f = new SyncTest();
synchronized (f) {...}

通过“this”在SyncTest实例本身中进行第二次测试：

程序中有2个线程：主线程和SyncTest线程。

---

每个线程都会通过SyncTest对象到达同步点，并等待另一个线程退出同步部分。

同一对象已经同步了2次

第一次上主课：

SyncTest f = new SyncTest();
synchronized (f) {...}

通过“this”在SyncTest实例本身中进行第二次测试：

程序中有2个线程：主线程和SyncTest线程。 每个线程都会通过SyncTest对象到达同步点，并等待另一个线程退出同步部分。

总结了

同步的功能，并指出块的内容无关紧要。所以问题不是为什么行为会改变，而是为什么它变化如此缓慢

您的线程“同步”（即逐个记录，即使
otherThread
应该快一点，有时在
mainThread
之前记录两次），因为您的
mainThread
在阻止同步对象时会连续休眠1500ms：

synchronized (f)
{
    for (int t = 0; t < 15; t++)  // this is
    {                             // (roughly)
        Thread.sleep(100);        // equivalent to 
    }                             // Thread.sleep(1500);
}

而
otherThread
将直接滑入100ms小睡之间的一个中断，空的同步块不再影响任何东西

注意空的同步块仍然有一点影响，并且可能会稍微改变日志的顺序，因为
otherThread
可能仍然需要等待一点（但最多只能等待100毫秒，而不是1500毫秒）。不过，它不会再产生如此严格的后四位限制。
总结了
synchronized
的功能，并提到块的内容无关紧要。所以问题不是为什么行为会改变，而是为什么它变化如此缓慢

您的线程“同步”（即逐个记录，即使
otherThread
应该快一点，有时在
mainThread
之前记录两次），因为您的
mainThread
在阻止同步对象时会连续休眠1500ms：

synchronized (f)
{
    for (int t = 0; t < 15; t++)  // this is
    {                             // (roughly)
        Thread.sleep(100);        // equivalent to 
    }                             // Thread.sleep(1500);
}

而
otherThread
将直接滑入100ms小睡之间的一个中断，空的同步块不再影响任何东西

注意空的同步块仍然有一点影响，并且可能会稍微改变日志的顺序，因为
otherThread
可能仍然需要等待一点（但最多只能等待100毫秒，而不是1500毫秒）。不过，它不会再产生如此严格的back和fourth。
synchronized

命令的目的是在线程之间进行同步。为什么仅仅因为它不包含任何代码，你就认为它没有效果？你是什么意思

使输出同步
自己复制并粘贴代码，你可以看到在有块和没有i的情况下输出会发生什么