Question

同步在此代码中正常工作：

    class PrintNumbers {
        synchronized public void display() {
            System.out.println("in display");
            for (int i = 0; i < 3; i++) {
                System.out.println("Thread name : "+ Thread.currentThread().getName() + " i= " + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.getMessage();
                }
            }
            System.out.println("out of display");
        }
    }

    class MyThread implements Runnable {
        Thread t;
        PrintNumbers printNumbers;

        MyThread(PrintNumbers printNumbers, String s) {
            this.printNumbers = printNumbers;
            t = new Thread(this,s);
            t.start();
        }

        public void run() {
            printNumbers.display();
        }
    }

    class SyncExample {
        public static void main(String[] args) {
            PrintNumbers printNumbers = new PrintNumbers();

            new MyThread(printNumbers, "My Thread 1");
            new MyThread(printNumbers, "My Thread 2");
        }
    }

输出

in display  
Thread name : My Thread 1 i= 0  
Thread name : My Thread 1 i= 1  
Thread name : My Thread 1 i= 2  
out of display
in display  
Thread name : My Thread 2 i= 0  
Thread name : My Thread 2 i= 1  
Thread name : My Thread 2 i= 2  
out of display

但不在此代码中：

    class PrintNumbers {
        synchronized public void display() {
            System.out.println("in display");
            for (int i = 0; i < 3; i++) {
                System.out.println("Thread name : "+ Thread.currentThread().getName() + " i= " + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.getMessage();
                }
            }
            System.out.println("out of display");
        }
    }

    class MyThread implements Runnable {
        Thread t;
        PrintNumbers printNumbers;

        MyThread(String s) {
            this.printNumbers = new PrintNumbers();
            t = new Thread(this,s);
            t.start();
        }

        public void run() {
            printNumbers.display();
        }
    }

    class SyncExample {
        public static void main(String[] args) {
            new MyThread("My Thread 1");
            new MyThread("My Thread 2");
        }
    }

输出

in display  
Thread name : My Thread 1 i= 0  
in display  
Thread name : My Thread 2 i= 0  
Thread name : My Thread 1 i= 1  
Thread name : My Thread 2 i= 1  
Thread name : My Thread 2 i= 2  
Thread name : My Thread 1 i= 2  
out of display  
out of display

我无法理解同步在Runnable MyThread和SyncExample类中初始化PrintNumbers所做的差异。请解释一下。

Answer 1

我无法理解同步在初始化Runnable MyThread和SyncExample类中的PrintNumbers方面有何不同。

没有。重要的是，在您的第一个示例中，您只有两个线程共享的一个 PrintNumbers实例。但在第二个示例中，您有两个单独的PrintNumbers实例，每个实例一个。

由于PrintNumbers#display在实例上同步（synchronized实例方法在this上同步），它只在实例内同步，而不是在多个实例之间同步。

当两个线程共享一个实例时，对display的两次调用都被序列化。但是当每个线程都有自己的实例时，对display的两次调用都在不同的实例上，因此没有序列化的调用，它们可以重叠。

Answer 2

因为在第二个代码中，每个线程都有自己的PrintNumbers对象，所以它们并行工作。在第一个中，他们共享单个PrintNumbers对象并以同步方式使用它。

PS。请记住，synchronized非静态方法会在对象上进行同步（对于类上的静态方法）。

Answer 3

这两种情况都适用。不同之处在于，在第一种情况下，您有一个同步的对象。在第二个你有两个。它们都只被调用一次，因此它们完美同步。

synchronized不在对象之间工作，只在一个对象中工作。

为什么同步在第二个代码中不起作用？

3 个答案: