java - lock()方法获取哪个对象的锁？

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

public class LockTest {
    Lock lck=new ReentrantLock();

    public void lockIt(){
        lck.lock();

        for(int i=0;i<10;i++) {
            System.out.println("i : "+ i);
            try{Thread.sleep(200);} catch (Exception e){}
        }
        lck.unlock();
    }

    public void test()
    {
        synchronized(this)     **// mark 1**
        {
            for(int j=0;j<10;j++)
            {
                System.out.println("val is"+j);
                try{Thread.sleep(200);}catch (Exception e){}
            }
        }
    }

    public static void main(String[] args) {
        LockTest obj=new LockTest();
        new Thread(new Runnable() {
            @Override
            public void run() {
                obj.lockIt();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                obj.test();
            }
         }).start();

     }
}

}
//在上述情况下，当我们说lck.lock（）;然后获得锁
实际是哪个对象？是“ this”还是“ lck”本身？

即使在“ this”或“ lck”对象上获得了锁
那怎么差线程能够进入关键部分
由相同的“ this”或“ lck”对象锁定。

情况1：当我们在mark1上使用synced（this）时。
情况2：当我们在标记1处使用synced（lck）时。

在这两种情况下，两个循环并行运行。

最佳答案

lck.lock()（在lck对象上）获得的锁与synchronized(this)或synchronized(lck)获得的锁完全无关。

如果要保护关键部分，则所有线程都必须使用相同的锁定机制（和相同的锁定）。

java.util.concurrent.locks.Lock是针对synchronized关键字不够灵活的情况引入的另一种机制。特别是，synchronized关键字在执行进入和离开块时自动获取并释放锁。在那里不可能在一种方法中获得锁，将其存储在某个位置，离开该方法并在以后的某个时间释放该锁。使用Lock对象，您可以执行这些操作（它还提供锁定等待超时，而synchronized可能会永远阻塞）。

关于java - lock()方法获取哪个对象的锁？，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/40702465/