06 | 用“等待-通知”机制优化循环等待

精选留言(145)

• 

  姜戈

  wait与sleep区别在于：
  1. wait会释放所有锁而sleep不会释放锁资源.
  2. wait只能在同步方法和同步块中使用，而sleep任何地方都可以.
  3. wait无需捕捉异常，而sleep需要.
  
  两者相同点：都会让渡CPU执行时间，等待再次调度！

  2019-03-12

   2

   180
• 

  Home

  补充一下姜戈同学回答；1 sleep是Thread的方法，而wait是Object类的方法；2：sleep方法调用的时候必须指定时间

  2019-03-12

  

   92
• 

  crazypokerk

  wait()方法与sleep()方法的不同之处在于，wait()方法会释放对象的“锁标志”。当调用某一对象的wait()方法后，会使当前线程暂停执行，并将当前线程放入对象等待池中，直到调用了notify()方法后，将从对象等待池中移出任意一个线程并放入锁标志等待池中，只有锁标志等待池中的线程可以获取锁标志，它们随时准备争夺锁的拥有权。当调用了某个对象的notifyAll()方法，会将对象等待池中的所有线程都移动到该对象的锁标志等待池。
  sleep()方法需要指定等待的时间，它可以让当前正在执行的线程在指定的时间内暂停执行，进入阻塞状态，该方法既可以让其他同优先级或者高优先级的线程得到执行的机会，也可以让低优先级的线程得到执行机会。但是sleep()方法不会释放“锁标志”，也就是说如果有synchronized同步块，其他线程仍然不能访问共享数据。

  作者回复: 👍
  

  2019-03-12

  

   82
• 

  wang

  public class MyLock {
  // 测试转账的main方法
  public static void main(String[] args) throws InterruptedException {
      Account src = new Account(10000);
      Account target = new Account(10000);
      CountDownLatch countDownLatch = new CountDownLatch(9999);
      for (int i = 0; i < 9999; i++) {
          new Thread(()->{
              src.transactionToTarget(1,target);
          countDownLatch.countDown();
          }).start();
      }
      countDownLatch.await();
      System.out.println("src="+src.getBanalce() );
      System.out.println("target="+target.getBanalce() );
  }
  static class Account{ //账户类
      public Account(Integer banalce) {
          this.banalce = banalce;
      }
      private Integer banalce;
      public void transactionToTarget(Integer money,Account target){//转账方法
          Allocator.getInstance().apply(this,target);
          this.banalce -= money;
          target.setBanalce(target.getBanalce()+money);
          Allocator.getInstance().release(this,target);
      }
      public Integer getBanalce() {
          return banalce;
      }
      public void setBanalce(Integer banalce) {
          this.banalce = banalce;
      }
  }
  static class Allocator { //单例锁类
      private Allocator(){}
      private List<Account> locks = new ArrayList<>();
      public synchronized void apply(Account src,Account tag){
          while (locks.contains(src)||locks.contains(tag)) {
              try {
                  this.wait();
              } catch (InterruptedException e) {
              }
          }
          locks.add(src);
          locks.add(tag);
      }
      public synchronized void release(Account src,Account tag){
          locks.remove(src);
          locks.remove(tag);
          this.notifyAll();
      }
      public static Allocator getInstance(){
          return AllocatorSingle.install;
      }
      static class AllocatorSingle{
          public static Allocator install = new Allocator();
      }
  }
  }

  作者回复: 高手高手，让我写也这不这样好👍👍👍👍👍
  

  2019-03-12

   7

   54
• 

  蜡笔

  老师你不用在文章中贴出所有代码嘛，只贴出核心代码，然后把整个例子放在github上，文末的时候给出github的链接，水平基础一般的就可以去上面下载下来跑一跑调试加深印象理解，这样可以不老师😂

  2019-03-12

  

   35
• 

  虎虎❤️

  困惑
  1. 对于从来没有获得过互斥锁的线程 所在的等待队列 和 因为wait() 释放锁而进入了等待队列，是否是同一个等待队列？也就是图中左侧和右侧的是否为同一个队列？
  2. notifyAll() 会发通知给等待队列中所有的线程吗？包括那些从未获得过互斥锁的线程吗？
  3. 因为wait()被阻塞，而又因为notify()重新被唤醒后，代码是接着在wait()之后执行，还是重新执行 apply 方法？

  作者回复: 不是一个队列
  只唤醒右侧的队列
  wait之后
  
  

  2019-03-14

   3

   30
• 

  andywang

  应该是!als.contains(from) || !als.contains(to)才wait()吧

  2019-03-12

   2

   18
• 

  郑晨Cc

  王老师 ABCD 那个例子真没看懂 线程1释放锁为啥会通知线程4？1和3才是互斥的啊 2和4互斥 按我的理解 3和4 不应该是在同一个等待队列里啊 因为不是通一把锁（准确来时不是同样的两把锁）
  就着这个例子 我还有个关互斥锁的等待队列的问题 假设还是资源ABCD 线程5 获取AB 线程6获取CD 线程7试图获取AB 线程8试图获取BC 线程9试图获取CD 那线程 7，8，9 到底是不是在一个等待队列里面，
  JVM在实现 wait notify机制是时候到底存不存在真实的队列？

  作者回复: 都是this这一把锁: synchronized void apply(){}
  所以是一个等待队列
  
  就是500个线程，也是同一个等待队列，因为锁的都是this
  
  队列一定是存在的

  2019-03-12

   4

   16
• 

  我是卖报小行家

  wait和sleep区别
  1：wait释放资源，sleep不释放资源
  2：wait需要被唤醒，sleep不需要
  3：wait需要获取到监视器，否则抛异常，sleep不需要
  4：wait是object顶级父类的方法，sleep则是Thread的方法

  作者回复: 全面👍
  

  2019-03-12

  

   15
• 

  kaizhi

  感觉老师讲解的节奏非常好，能把并发讲解的这么浅显易懂绝非一日之功。老师在用一种由浅入深，逐层深入的方法来讲解java并发的这些知识点，而不是一股脑的把所有的知识点都罗列出来，有助于我们的吸收，也能引发我们的进一步思考，譬如这节的wait方法，就是在改进上一节的while循环等待（上一节的while在评论区就引发了各路高手的强烈不满，哈哈），这样有助于我们理解当年java的开发者在设计wait方法时的出发点在哪里，另外也让我们理解了为什么wait，notify，notifyAll这些方法会作为Object类的方法。用现实生活做类比这一点也很赞，之前有艺术来源于生活而又高于生活，现在可以说技术来源于生活而又高于生活了，哈哈~

  作者回复: 感谢你这么懂我😂
  

  2019-03-15

  

   13
• 

  老杨同志

  点赞@姜戈 补充一下：wait与sleep区别在于：
  1. wait会释放所有锁而sleep不会释放锁资源.
  2. wait只能在同步方法和同步块中使用，而sleep任何地方都可以.
  3. wait无需捕捉异常，而sleep需要.（都抛出InterruptedException ，wait也需要捕获异常）
  4. wait()无参数需要唤醒，线程状态WAITING；wait(1000L);到时间自己醒过来或者到时间之前被其他线程唤醒，状态和sleep都是TIME_WAITING
  两者相同点：都会让渡CPU执行时间，等待再次调度！

  作者回复: 👍
  

  2019-03-12

  

   13
• 

  邋遢的流浪剑客

  wait会释放当前占有的锁，sleep不会释放锁

  2019-03-12

  

   11
• 

  lau

  看评论也能学到很多干货

  2019-03-14

  

   9
• 

  aksonic

  老师，我昨天问了你问题后，带着疑问又去学习了下，是不是文章中的左边和右边的两个队列应该改一改名字，不应该都叫等待队列，这样对新手很容易产生误解。如果左边的叫做同步队列，右边的叫做等待队列可能更好。左边的队列是用来争夺锁的，右边的队列是等待队列，是必须被notify的，当被notify之后，就会被放入左边的队列去争夺锁。老师，你觉得呢？

  作者回复: 你这个建议挺好，在管程里面，会重新讲这俩队列。现在就知道有俩等待队列就可以了
  

  2019-03-14

   1

   7
• 

  陈志凯

  public class Allocator {
  private final List<Account> als=new LinkedList<Account>();
  // 一次性申请所有资源
  public synchronized void apply(Account from, Account to) {
  // 经典写法
  while (als.contains(from) || als.contains(to)) {
  try {
  System.out.println("等待用户 -> "+from.getId()+"_"+to.getId());
  wait();
  } catch (Exception e) {
  //notify + notifyAll 不会来这里
  System.out.println("异常用户 -> "+from.getId()+"_"+to.getId());
  e.printStackTrace();
  }
  }
  als.add(from);
  als.add(to);
  }
  // 归还资源
  public synchronized void free(Account from, Account to) {
  System.out.println("唤醒用户 -> "+from.getId()+"_"+to.getId());
  als.remove(from);
  als.remove(to);
  notifyAll();
  }
  }
  
  public class Account {
  // actr 应该为单例
  private final Allocator actr;
  //唯一账号
  private final long id;
  //余额
  private int balance;
  public Account(Allocator actr,long id,int balance){
  this.actr=actr;
  this.id=id;
  this.balance=balance;
  }
  // 转账
  public void transfer(Account target, int amt) {
  // 一次性申请转出账户和转入账户，直到成功
  actr.apply(this, target);
  try {
  //TODO 有了资源管理器，这里的synchronized锁就不需要了吧？！
  if (this.balance > amt) {
  this.balance -= amt;
  target.balance += amt;
  }
  //模拟数据库操作时间
  try {
  Thread.sleep(new Random().nextInt(2000));
  } catch (InterruptedException e) {
  e.printStackTrace();
  }
  } finally {
  actr.free(this, target);
  }
  }
  @Override
  public int hashCode() {
  final int prime = 31;
  int result = 1;
  result = prime * result + (int) (id ^ (id >>> 32));
  return result;
  }
  /**
  * 用于判断两个用户是否一致
  */
  @Override
  public boolean equals(Object obj) {
  if (this == obj)
  return true;
  if (obj == null)
  return false;
  if (getClass() != obj.getClass())
  return false;
  Account other = (Account) obj;
  if (id != other.id)
  return false;
  return true;
  }
  public long getId() {
  return id;
  }
  }
  老师，以上代码是我补的，有个疑问，以上有了Allocator管理器（见TODO部分），transfer方法的this跟target都不再需要加synchronized锁了吧？！

  作者回复: 如果只是这个例子就不需要了，
  送你俩字！优秀！！！！！

  2019-03-13

  

   7
• 

  陈志凯

  强烈建议老师每个章节配上完整的demo，包括模拟多线程多个客户操作的代码，这样看效果才是最佳的，我们自己也能根据代码实际好好观察！

  作者回复: 对于水平高的，完整的代码没必要。对于水平低的，完整的代码只能增加惰性。我就很讨厌粘贴一些无关的代码😃

  2019-03-12

   1

   7
• 

  高源

  老师最好讲解每一章的时候配合完整的例子源代码，这样再加调试源代码，印象更深刻了

  作者回复: 大家水平不一样，有些高水平的可能只想看到核心的代码，我怕贴多了，有人说浪费流量。自己补上剩余代码也是个不错的提高机会吧😂

  2019-03-12

  

   7
• 

  约书亚

  置顶回答是不是有问题，wait一样需要捕获InterruptedException异常呀？

  作者回复: 你是对的

  2019-03-12

  

   5
• 

  San D Ji

  学习这几章以后，我一直有一个问题，Javaweb端在什么样的业务场景下需要多线程的技术实现？
  一直以为Javaweb端都是接收到一个请求服务器端开启一条线程独立作业，完了之后就返回一个应答。
  不知道老师能否回答一下我的疑问？

  作者回复: 比如你要做个数据库连接池，做个httpclient，做个rpc框架，用批处理处理上千万数据，一个简单的crud真的用不上
  

  2019-03-12

  

   4
• 

  ^_^

  老师，while(als.contains(from) || als.contains(to)) 这句对吗

  作者回复: 我确认了一下，应该是对的
  只要有一个，就说明曾经被分配过
  

  2019-03-12

   2

   4