突然有个问题：
cpu层面的原子性是单条cpu指令。
java层面的互斥（管程）保证了原子性。
这两个原子性意义应该不一样吧？
我的理解是cpu的原子性是不受线程调度影响，指令要不执行了，要么没执行。而java层面的原子性是在锁的机制下保证只有一个线程执行，其余等待，此时cpu还是可以进行线程调度，使运行中的那个线程让出cpu时间，当然了该线程还是掌握锁。
我这样理解对吧？

class Account {
  private int balance;
  private final Lock lock
          = new ReentrantLock();
  // 转账
  void transfer(Account tar, int amt){
    boolean flag = true;
    while (flag) {
      if(this.lock.tryLock(随机数，NANOSECONDS)) {
        try {
          if (tar.lock.tryLock(随机数，NANOSECONDS)) {
            try {
              this.balance -= amt;
              tar.balance += amt;
     flag = false;
            } finally {
              tar.lock.unlock();
            }
          }//if
        } finally {
          this.lock.unlock();
        }
      }//if
    }//while
  }//transfer
}
感觉可以这样操作

1、转账成功跳出循环，避免死循环
2、锁自己账户时，加一个随机等待时间，避免活锁
3、锁目标账户时，锁不到则直接解锁
class Account {
    private int balance;
    private final Lock lock = new ReentrantLock();
    // 转账
    void transfer(Account tar, int amt){
        while (true) {
         if(this.lock.tryLock(随机数，NANOSECONDS)) {
                try {
                    if (tar.lock.tryLock()) {
                        try {
                            this.balance -= amt;
                            tar.balance += amt;
                            // 转账成功结束循环
                            break;
                        } finally {
                            tar.lock.unlock();
                        }
                    }//if
                } finally {
                    this.lock.unlock();
                }
            }//if
        }//while
    }//transfer
}

老师，你好，这是我第二遍研读你的课程了，每一遍都收获很大。第一次写留言有点紧张。
你上面写的jdk利用内存模型的三条规则来保证可见性，是正确的。但我觉得好像描述的理由好像不充分，我不知道我理解的对不对，请老师解答一下
我的理解应该是 ：1）释放锁成功后，写state的值 （unlock>state-=1） 顺序性
2）获取锁前，读state值（state>lock）顺序性
3）传递性 unlock>lock

下面是jdk的源码
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();//获取当前线程实例
    int c = getState();//获取state变量的值,即当前锁被重入的次数
    if (c == 0) { //state为0,说明当前锁未被任何线程持有
        if (compareAndSetState(0, acquires)) { //以cas方式获取锁
            setExclusiveOwnerThread(current); //将当前线程标记为持有锁的线程
            return true;//获取锁成功,非重入
        }
    }
    else if (current == getExclusiveOwnerThread()) { //当前线程就是持有锁的线程,说明该锁被重入了
        int nextc = c + acquires;//计算state变量要更新的值
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);//非同步方式更新state值
        return true; //获取锁成功,重入
    }
    return false; //走到这里说明尝试获取锁失败
}