为什么我的同步方法可以锁定不同的对象？

Question

我现在正在学习Java并发。 我遇到了一段这样的代码：

package pac1;

import java.util.*;
import java.util.concurrent.*;

class A1 {
    public void f() {
        synchronized (this) {
            for (int i = 0; i < 5; i++)
                System.out.println("f()");
        }
    }
}

class B1 {
    public void g() {
        synchronized (this) {
            for (int i = 0; i < 5; i++)
                System.out.println("g()");
        }
    }
}

class C1 {
    public void p() {
        synchronized (this) {
            for (int i = 0; i < 5; i++)
                System.out.println("p()");
        }
    }

}

public class V {
    public static void main(String[] args) {
        A1 a = new A1();
        B1 b = new B1();
        C1 c = new C1();
        new Thread() {
            public void run() {
                a.f();
            }
        }.start();
        new Thread() {
            public void run() {
                c.p();
            }
        }.start();
        b.g();
    }

}

由于此代码使用不同的对象来调用同步方法，因此我认为这不会阻止它们相互干扰。 但是，结果如下：

f()
f()
f()
f()
f()
g()
g()
g()
g()
g()
p()
p()
p()
p()
p()

顺便说一句，使用Lock的结果是相同的：

package pac1;

import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class A {
    Lock lock = new ReentrantLock();

    public void f() {
        lock.lock();
        try {
            for (int i = 0; i < 5; i++)
                System.out.println("f()");
        } finally {
            lock.unlock();
        }
    }
}

class B {
    Lock lock = new ReentrantLock();

    public void g() {
        lock.lock();
        try {
            for (int i = 0; i < 5; i++)
                System.out.println("g()");
        } finally {
            lock.unlock();
        }
    }
}

class C {
    Lock lock = new ReentrantLock();

    public void p() {
        lock.lock();
        try {
            for (int i = 0; i < 5; i++)
                System.out.println("p()");
        } finally {
            lock.unlock();
        }
    }
}

public class Ex16 {

    public static void main(String[] args) {
        A a = new A();
        B b = new B();
        C c = new C();
        new Thread() {
            public void run() {
                a.f();
            }
        }.start();
        new Thread() {
            public void run() {
                c.p();
            }
        }.start();
        b.g();
    }

}

Answer 1

您不需要在这里锁定或同步。 同步用于锁定对共享可变状态的访问。 首先，您没有任何共享的可变状态。

这里有3个线程，由于上下文切换，没有人能预测这些线程的运行顺序。 我没问题。

Answer 2

实际上，循环还不够长，因此允许线程以与启动时相同的顺序完成。 为了使线程不干扰您可以尝试以下方法之一：

• 使循环运行更长的时间，例如1000次迭代就应该足够了：

  synchronized (this) { for (int i = 0; i < 1000; i++) System.out.println("f()"); }

• 挂起循环中的线程，但请确保为每个循环设置不同的间隔：

  synchronized (this) { for (int i = 0; i < 5; i++) { System.out.println("p()"); try { Thread.sleep(3000); } catch (final InterruptedException ex) { // Swallow } } }

长话短说：这些锁实际上并不干扰。