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

精选留言(68)

• 

  magict4

  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) 方法。

  作者回复: 👍👍
  

  2019-03-26

   3

   50
• 

  海鸿

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

  作者回复: 相当正确！
  

  2019-03-26

  

   16
• 

  QQ怪

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

  作者回复: 👍
  

  2019-03-27

  

   9
• 

  Boomkeeper

  我就不明白了，使用了synchronized，为啥还用voliate，他的确是保证可见性，但是并不能保证原子性，一般他的应用场景应该是不依赖之前的结果而改变数据，累加的场景明显不适合

  2019-04-09

   1

   5
• 

  Cc

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

  作者回复: 我觉得这个没有问题，volatile 换成 final会更好

  2019-03-29

  

   4
• 

  抽离の❤️

  老师、讲的真好！

  2019-03-26

  

   3
• 

  悟空

  访问时使用syncchronize对类加锁。保证变量访问的互斥

  作者回复: 对象加锁就可以了
  

  2019-03-26

  

   2
• 

  Lemon

  使用 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();
          }
      }
  
  }

  作者回复: 错误的设置会导致永远等待，太危险了
  

  2019-03-26

  

   2
• 

  Zm

  Volatile修饰变量

  2019-03-26

  

   2
• 

  无庸

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

  作者回复: 不满足合理库存的约束条件
  

  2019-03-26

  

   2
• 

  京

  一早起来，就把文章看完了，期待老师后面更精彩的内容

  2019-03-26

  

   2
• 

  逆水行舟

  那本书，有些晦涩，但是是必读的。

  作者回复: 太晦涩了

  2019-03-31

  

   1
• 

  阿琨

  老师，这样写有什么问题吗，总感觉哪里怪怪的。
  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;
      }
  }

  作者回复: 没问题
  

  2019-03-26

  

   1
• 

  江南豆沙包

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

  作者回复: 感谢信任！我们这里说的共享是进程级别的，如果是分布式计算只能靠redis,db,zk这些来搞分布式的锁，当然不共享是最好的解决方案。

  2019-03-26

  

   1
• 

  undifined

  要保证变量间的约束条件，就必须保证判断和赋值是一个原子操作，可以通过给 upper 和 lower 同时加锁，也可以通过 AtomicLong 提供的方法进行操作
  
      // 设置库存上限
      void setUpper(long v) {
          // 检查参数合法性
          upper.getAndUpdate(u -> {
              if (v < lower.get()) {
                  throw new IllegalArgumentException();
              } else {
                  return v;
              }
          });
      }
  
      // 设置库存下限
      void setLower(long v) {
          // 检查参数合法性
          lower.getAndUpdate(u -> {
              if (v > upper.get()) {
                  throw new IllegalArgumentException();
              } else {
                  return v;
              }
          });
      }
   
  老师这样理解对吗

  作者回复: 我感觉不可以，还是有竞态条件，你可以在return前面增加sleep看看

  2019-03-26

  

   1
• 

  xlz

  validate我看书中说像a=4这种是有原子性的，对于复合操作是没有原子性，望老师解答

  作者回复: 是这样的，可以使用JDK提供的原子类

  2019-11-30

  

  
• 

  大大。

  加一个lock，在set里面去获取lock，获取到的才能set

  2019-11-29

  

  
• 

  朕爱吾妃

  最简单的方法就是加synchronized关键字，不过我不认为这是最佳的解决方案，这个方案违反了三个原则中两个原则，第二个原则和第三个原则，先说第三个原则，其实加上synchronized是属于过早的优化，解决方案就是可以创建一个不变的对象，然后不管是设置上限还是设置下限都需要对这个资源进行竞争，不过也没有晚多少优化，但是这个方案没有解决第二个原则，因为还是会使用到synchronized的关键字... ...，这个我没法解决

  2019-11-11

  

  
• 

  吃饭饭

  不能锁 synchronized(当前参数值) 吗？

  2019-10-16

  

  
• 

  DFighting

  用前几章的那个转账例子用到的，每次执行set方法时都要在一个Lock方法中持有上限和下限，然后判断是否符合约束，线程间协作可以考虑synchronized+wait()+notifyAll()或Lock+Condition实现；
  

  2019-09-19

  

  