又想到一种，既然两个变量要同时锁定，那就把两个变量封装成一个，然后使用cas操作。这样行不行，另外老师帮我看看volatile是不是有多余的地方
···········
volatile AtomicReference<Inventory> inventory = new AtomicReference<>();

    static class Inventory {
        private volatile long upper = 0;

        private volatile long lower = 0;
    }

    void setUpper(long v) {
        long low;
        Inventory oldObj;
        Inventory newObj;
        do {
            oldObj = inventory.get();
            if (v >= (low = oldObj.lower)) {
                throw new IllegalArgumentException();
            }
            newObj = new Inventory();
            newObj.lower = low;
            newObj.upper = v;

        } while (inventory.compareAndSet(oldObj, newObj));
    }

    void setLower(long v) {
        long upp;
        Inventory oldObj;
        Inventory newObj;
        do {
            oldObj = inventory.get();
            if (v <= (upp = oldObj.upper)) {
                throw new IllegalArgumentException();
            }
            newObj = new Inventory();
            newObj.lower = v;
            newObj.upper = upp;

        } while (inventory.compareAndSet(oldObj, newObj));
    }

老师，这样写有什么问题吗，总感觉哪里怪怪的。
public class DBPush {
    private volatile static DBPush dbPush = null;

    private DBPush() {
    }

    public static DBPush getInStance() {
        if (dbPush == null) {
            synchronized (DBPush.class) {
                if (dbPush == null) {
                    dbPush = new DBPush();
                }
            }
        }
        return dbPush;
    }
}

使用 Condition
public class SafeWM {

    // 库存上限
    private final AtomicLong upper =
            new AtomicLong(10);
    // 库存下限
    private final AtomicLong lower =
            new AtomicLong(2);

    private ReentrantLock lock = new ReentrantLock();
    private Condition c1 = lock.newCondition();
    private Condition c2 = lock.newCondition();
    
    // 设置库存上限
    void setUpper(long v) {
        try {
            lock.lock();
            // 检查参数合法性
            while (v < lower.get()) {
                c1.await();
            }
            upper.set(v);
            c2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

    // 设置库存下限
    void setLower(long v) {

        try {
            lock.lock();
            // 检查参数合法性
            while (v > upper.get()) {
                c2.await();
            }
            lower.set(v);
            c1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

compareAndSet吧

void setUpper（long v）{
  upper.compareAndSet(upper.longValue
(),v);
}

---总结---
1. 封装与并发：将共享变量作为对象属性封装在内部，对所有公共方法指定并发访问策略
2. 不可变与并发：如无必要修改，实例变量都应该是private final的
3. 共享变量间的约束条件决定了并发访问策略，而为了达到这种约束条件，基本上都会有if语句，此时往往会出现竞态条件
4. 并发访问策略：避免共享；不变模式；同步工具

---启发---
1. 经常能将计算机的两个概念放在一起，看看两者的关联，会有不同的收获。

public class SafeWM {
  // 库存上限
  private final AtomicLong upper =
        new AtomicLong(0);
  // 库存下限
  private final AtomicLong lower =
        new AtomicLong(0);
  // 设置库存上限
  void setUpper(long v) {
    synchronized (this) {
      // 检查参数合法性
      if (v < lower.get()) {
        throw new IllegalArgumentException();
      }
      upper.set(v);
    }
  }
  // 设置库存下限
  void setLower(long v) {
    synchronized (this) {
      // 检查参数合法性
      if (v > upper.get()) {
        throw new IllegalArgumentException();
      }
      lower.set(v);
    }
  }
  // 省略其他业务代码
}

老师，这样处理可以吗？