synchronized关键字拓展

之前一直以为，只有在同一个线程类中使用同一个对象作为对象锁，才会实现同步，今天突然发现，两个不同的线程类使用同一个对象作为对象锁的话，也会实现同步，上代码

public class ThreadA extends Thread {

    private Object lock;

    public ThreadA(Object lock) {
        super();
        this.lock = lock;
    }

    @Override
    public void run() {
        try {
            synchronized (lock) {
                for (int i = 0; i < 100; i++) {
                    System.out.println(i);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class ThreadB extends Thread {

    private Object lock;

    public ThreadB(Object lock) {
        super();
        this.lock = lock;
    }

    @Override
    public void run() {
        try {
            synchronized (lock) {
                for (int i = 100; i < 200; i++) {
                    System.out.println(i);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class Task {

    public static void main(String[] args) {

        try {
            Object lock = new Object();

            ThreadA a = new ThreadA(lock);
//            Thread.sleep(50);
            ThreadB b = new ThreadB(lock);
            a.start();
            b.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

可以看见ThreadA和ThreadB是两个不同的线程类，但是他们使用了相同的对象作为对象锁，实现了同步。