1

这是从互联网某处复制的代码:
这个显式锁定如何工作?

public class Lock {
  private Object lockObj = new Object();
  private Thread owner;
  private int lockCount;

  /**
   * Waits for up to 'maxWait' milliseconds to acquire the lock,
   * and returns true if the lock was acquired.
   **/
  public boolean acquireLock(int maxWait) throws InterruptedException {
    Thread currentThread = Thread.currentThread();
    synchronized (lockObj) {
      if (owner == currentThread) {
        lockCount++;
        return true;
      }
      long waitedSoFar = 0L;
      while (owner != null) {
        long t0 = System.currentTimeMillis();
        long timeToWait = maxWait - waitedSoFar;
        if (timeToWait <= 0)
          return false;
        lockObj.wait(timeToWait);
        if (owner != null) {
          waitedSoFar += System.currentTimeMillis() - t0;
        }
      }
      owner = currentThread;
      lockCount = 1;
      return true;
    }
  }
  public void releaseLock() {
    Thread currentThread = Thread.currentThread();
    synchronized (lockObj) {
      if (owner == currentThread) {
        lockCount--;
        if (lockCount == 0) {
          owner = null;
          lockObj.notify();
        }
        return;
      } else {
        // Only the owner can release the lock!
        throw new IllegalStateException();
      }
    }
  }
}

我还没有看到任何特殊代码来保证内存可见性。唯一与并发相关的是“synchronized(lockObj){ ... }”

那是魔法吗?
CPU 在获取一些同步监视器之前是否只是刷新其所有缓存?
还是相反?
当释放一些同步监视器时,CPU 是否只是刷新其所有缓存?

编辑:
嗯,我得到了一些与并发等待/通知相关的其他事情。

想想看。这个显式锁是如何工作的?

  1. 获取锁,修改变量(防止其他线程获取),然后释放锁。
  2. 做任何事情。
  3. 获取锁,修改变量(允许其他线程获取)。
  4. 其他一些线程获取锁,然后循环......

之前发生的关系只是在 3 和 4 之间,对吗?
还是在 1 和 3 之间也可以保证发生前的关系?那么2是保证内存可见性吗?

4

1 回答 1

1

没有 cpu 可以获取的同步监视器之类的东西。监视器是在您正在编程的语言(在本例中为 java)的运行时中实现的结构。

java 运行时负责此锁定并禁止其他代码进入同步的代码块。cpu 只看到处理它的指令。

关于缓存问题:cpu 不仅仅决定刷新缓存。缓存会一直保留,直到被覆盖。

于 2012-09-15T09:50:33.567 回答