synchronized在修饰代码块的时候，括号后面要跟什么啊？

Question

package basic;

public class TestSynchronizedObject {

    public static void main(String[] args) {
        final TestSynchronizedObject testSynchronizedObject_first = new TestSynchronizedObject();
        final TestSynchronizedObject testSynchronizedObject_second = new TestSynchronizedObject();
        final MyObject myObject_first = new MyObject();
        final MyObject myObject_seconde = new MyObject();
        new Thread("线程A") {

            @Override
            public void run() {
                myObject_first.print("线程A");
            }
        }.start();
        new Thread("线程B") {

            @Override
            public void run() {
                myObject_seconde.print("线程B");
            }
        }.start();
    }
}

class MyObject {

    public void print(String str) {
        System.out.println("线程" + Thread.currentThread().getName() + "开始执行");
        synchronized ("") {
            for (int i = 0; i < 10; i++) {
                System.out.println(str + " ." + i + ". ");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                }
            }
        }
        System.out.println("线程" + Thread.currentThread().getName() + "执行结束");
    }
}
//输出结果：
//线程线程A开始执行
//线程A .0. 
//线程线程B开始执行
//线程A .1. 
//线程A .2. 
//线程A .3. 
//线程A .4. 
//线程A .5. 
//线程A .6. 
//线程A .7. 
//线程A .8. 
//线程A .9. 
//线程B .0. 
//线程线程A执行结束
//线程B .1. 
//线程B .2. 
//线程B .3. 
//线程B .4. 
//线程B .5. 
//线程B .6. 
//线程B .7. 
//线程B .8. 
//线程B .9. 
//线程线程B执行结束

查阅相关文档，当synchronized修饰代码块的时候，表示线程在执行的时候会将synchronized括号中的对象上锁。（注意这个对象可以是任意类的对象，也可以使用this关键字）。但是我这里明明是两个实例，而且在synchronized修饰代码块的时候，我的括号中明明没有指定在什么对象上使用锁，为什么是这样的打印结果呢？

Answer 1

synchronized (lock-object) {
}

括号后面要跟一个对象，这个对象充当锁的作用。
synchronized("")，这里你把一个空字符串当成锁，并因此认为你没有指定锁住哪个对象。
而实际上，空字符串本身就是一个对象。并且，你有两个实例，并把空字符串喂给它们，这两个实例实际上持有的是同一个对象。

1. 在Java中，全部都是对象， 空字符串也是对象。

2. 常量字符串，比如空字符串，都放在常量池里，两个实例引用的空字符串实际上就是常量池里的空字符串，是同一个对象。