12 | 如何用面向对象思想写好并发程序？

1. setUpper() 跟 setLower() 都加上 "synchronized" 关键字。不要太在意性能，老师都说了，避免过早优化。 2. 如果性能有问题，可以把 lower 跟 upper 两个变量封装到一个类中，例如 ``` public class Boundary { private final lower; private final upper; public Boundary(long lower, long upper) { if(lower >= upper) { // throw exception } this.lower = lower; this.upper = upper; } } ``` 移除 SafeVM 的 setUpper() 跟 setLower() 方法，并增入 setBoundary(Boundary boundary) 方法。

我看有些人评论用volatie，volatie只能保证可见性，但是保证不了原子性，所以得加锁保证互斥。 老师我这样理解对吗？

令哥，一直在追你的专栏，结合公司目前实际情况，有个疑问，如果你专栏中的例子中的共享信息，是整个系统维度的，系统又是多实例集群部署的，我们该怎么办呢，能不能在思想或实现思路上给点建议指导。

必须加锁啊，synchronized (this)就行了，最简单加锁吧，volatile只能保证内存可见性，并不能保证原子性

前面有个朋友说final保证不会逃逸，理解应该有误，fianl的禁止重排序前提是构造函数里面没有this逃逸，他只保证final变量不会重排序到构造函数之外。并不保证逃逸。

思考题:对于两个互相比较的变量来说，赋值的时候只能加锁来控制。但是这也会带来性能问题，不过可以采用读锁和写锁来优化，申请写锁了就互斥，读锁可以并发访问，这样性能相对粗粒度的锁来说会高点。

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); } } // 省略其他业务代码 } 老师，这样处理可以吗？

又想到一种，既然两个变量要同时锁定，那就把两个变量封装成一个，然后使用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)); }

「迫不得已时才使用低级的同步原语：低级的同步原语主要指的是 synchronized、Lock、Semaphore 等，这些虽然感觉简单，但实际上并没那么简单，一定要小心使用。」 老师您好，这里内置锁和显式锁都是低级同步原语，那什么是高级同步原语呢？

老师，这个方案如何？ public class SafeVm { private volatile long upNum = 10; private volatile long lowNum = 1; private ReadWriteLock upLock = new ReentrantReadWriteLock(); private ReadWriteLock lowLock = new ReentrantReadWriteLock(); void setUpper(long newUpValue) { lowLock.readLock().lock(); try { if (newUpValue < lowNum) { throw new IllegalArgumentException(); } upLock.writeLock().lock(); try { upNum = newUpValue; } finally { upLock.writeLock().unlock(); } } finally { lowLock.readLock().unlock(); } } void setLower(long newLowValue) { upLock.readLock().lock(); try { if (newLowValue > upNum) { throw new IllegalArgumentException(); } lowLock.writeLock().lock(); try { lowNum = newLowValue; } finally { lowLock.writeLock().unlock(); } } finally { upLock.readLock().unlock(); } } }