Java 通用同步代码块[无对象锁定]

这是我提出的一个简单代码来说明我的问题：

public class Main {
    public static void main(String[] args) {
        int sleepTime = 10, N = 1000;
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < N; i++) {

                { //BLOCK 1
                    //I want these two instructions to run one right after the other one
                    System.out.println("Thread one rules!!");
                    System.out.println("Im in 1!!!\n");
                }

                try {
                    Thread.sleep(sleepTime); //I also tried yield
                } catch (InterruptedException e) {}
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < N; i++) {

                { //BLOCK 2
                    //I want these two instructions to run one right after the other one
                    System.out.println("Thread two rules!!");
                    System.out.println("Im in 2!!!\n");
                }

                try {
                    Thread.sleep(sleepTime); //I also tried yield
                } catch (InterruptedException e) {}
            }
        });

        t1.start();
        t2.start();

        t1.join();
        t2.join();
    }
}

公共类主{
公共静态void main（字符串[]args）{
int sleepTime=10，N=1000；
线程t1=新线程（（）->{
对于（int i=0；i{
对于（int i=0；i

是否有一种方法可以将每个块称为“原子”块？意思是“线程一规则！！”总是在“我在1！！！”之前出现

我不想在同步块中使用任何虚拟对象，也不想使用任何wait/notify语句。我想要一个可以与数百个线程一起运行的实现。我尝试使用以公共对象作为参数的同步语句mySocketServer，但它开始给我带来计时问题

---

提前感谢

否，您必须锁定系统周围。关闭以防止 线程一规则！！ 穿两条规则

---

即使锁定每个块，也将允许两个线程同时向System.out写入数据

最相关的方法是使用单个调用：

System.out.println("<first line>\n<second line>");

---

这绝对不应该影响时机。像println（）这样的PrintStream方法已经包含了这种同步，因此这个额外的同步块将更好地优化锁定

“虚拟对象”是指所有线程共享的

最终对象锁=新对象（）

？这将是常见的做法。即使有数百个线程，如果你想建立一个所有线程都服从的锁，那么根本就没有办法让所有线程都使用同一个锁，对吗？此外，除非您的CPU有数百个内核，否则拥有数百个线程并没有多大好处，除非每个线程都花费大量时间等待资源（比如需要一段时间的URL响应）。如果是这样的话，那么它们锁定在同一个对象上就无关紧要了。运行程序的硬件的功能是有限的。同时运行的数百个线程可能会对相当强大的硬件造成压力，是的，强迫它们序列化对单个资源的访问可能会加快性能问题的出现。可能你需要更多的硬件。可能您需要全面的设计改进。但是，您需要的那种“原子性”只能通过一种或另一种锁定来实现。您是否特别关心到标准输出（或其他一些I/O流）的输出？在这种情况下，普通的

java.io.

类都不能保证原子性，因为它们可以随时阻塞（并挂起线程）。事实上，我不知道任何操作系统在一般情况下都可以这样做，而特殊情况通常是操作系统特定的。您有两个代码块，由两个不同的线程执行，并且您希望确保一次只有一个线程在“关键”代码块内。这意味着，如果另一个线程想要进入关键块，它必须等到第一个线程退出其关键块。这种等待状态最好通过获得锁来实现。任何其他机制都会产生相同的效果，即第二个线程等待，那么为什么您认为锁定会导致过度的性能问题呢？降低性能的是等待，而不是锁。你的问题毫无意义。锁是让线程等待的最有效方法，因为它实际上会停止线程，让CPU做其他事情。如果线程必须等待事件，那么锁定是迄今为止最有效的方法。对于您指定的问题，锁定是正确的工具，那么您为什么要寻找其他解决方案呢？无论是使用

synchronized

、

ReadWriteLock

、

信号灯

、还是任何其他可用的并发工具进行锁定，锁定都是锁定。

synchronized(System.out) {
...
}