献给母亲节（object=>wait/notify)

本文属于装糊涂的猪原创，转载请注明出处作者

背景交代：
  在上一篇OTA升级中有提到Nordic提供的升级库，看源码时发现如下一些代码：

private final Object mLock = new Object();
synchronized (mLock)
{ 
 mLock.notify();
}
synchronized (mLock) 
 {
 while ((mConnectionState == STATE_CONNECTING
|| mConnectionState ==STATE_CONNECTED) && mError == 0)
mLock.wait();
 }

心生疑惑，Object还能这么玩的啊？wait 、notify不是线程中的东东吗？

mb.jpg

于是我找到官方的 Object Class API,上面写道：

Class Object is the root of the class hierarchy. Every class has Object as a superclass. All objects, including arrays, implement the methods of this class.
显然是万类之母啊，本周末就是母亲节了，以本文献祭给母亲节了。

ty.gif

看下wait函数说明（如下图） ：

waitapi.png

再看下notify函数说明（如下图） ：

notify.jpg

欧了，大体的意思应该是如下图：

Wait and Notify Java Concurrency.jpg

于是撸出如下代码：

public class LockTest01 {

    
    static Object lock = new Object();
    static boolean b =true;
    
    /**
     * @param args
     */
    public static void main(String[] args) {
            
        new Thread(){
            public void run() {
                synchronized (lock) {
                    while (b){
                        try {
                            System.out.println("wait start");
                            lock.wait();
                            try {
                                //do something
                                Thread.sleep(2000);
                                b=false;
                                System.out.println("wait  sleep  2s");
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                            System.out.println("wait end");
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            };
        }.start();
        
        new Thread(){
            public void run() {
                synchronized (lock) {
                    System.out.println("notify start");
                    try {
                        //do something
                        Thread.sleep(2000);
                        System.out.println("notify  sleep  2s");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    lock.notify();
                    System.out.println("notify end");
                }
            };
        }.start();
            
    }

}

Output:
wait start
notify start
notify  sleep  2s
notify end
wait  sleep  2s
wait end

但是这个究竟有什么应用场景呢？
  比较典型的就是producer consumer problem，现在就以此为例：
  1)生产者线程每1秒生成一个新资源，并将其放入“taskQueue”中。
  2)消费者线程需要1秒的时间来处理从“任务队列”中消耗的资源。
  3)任务队列的最大容量为5，在任何给定的时间内，可以在“任务队列”中存在最多5个资源。
  4)两个线程都是无限运行的。

Producer Design

class Producer implements Runnable
{
   private final List taskQueue;
   private final int           MAX_CAPACITY;
 
   public Producer(List sharedQueue, int size)
   {
      this.taskQueue = sharedQueue;
      this.MAX_CAPACITY = size;
   }
 
   @Override
   public void run()
   {
      int counter = 0;
      while (true)
      {
         try
         {
            produce(counter++);
         } 
         catch (InterruptedException ex)
         {
            ex.printStackTrace();
         }
      }
   }
 
   private void produce(int i) throws InterruptedException
   {
      synchronized (taskQueue)
      {
         while (taskQueue.size() == MAX_CAPACITY)
         {
            System.out.println("Queue is full " + Thread.currentThread().getName() + " is waiting , size: " + taskQueue.size());
            taskQueue.wait();
         }
           
         Thread.sleep(1000);
         taskQueue.add(i);
         System.out.println("Produced: " + i);
         taskQueue.notifyAll();
      }
   }
}

Consumer Design

class Consumer implements Runnable
{
   private final List taskQueue;
 
   public Consumer(List sharedQueue)
   {
      this.taskQueue = sharedQueue;
   }
 
   @Override
   public void run()
   {
      while (true)
      {
         try
         {
            consume();
         } catch (InterruptedException ex)
         {
            ex.printStackTrace();
         }
      }
   }
 
   private void consume() throws InterruptedException
   {
      synchronized (taskQueue)
      {
         while (taskQueue.isEmpty())
         {
            System.out.println("Queue is empty " + Thread.currentThread().getName() + " is waiting , size: " + taskQueue.size());
            taskQueue.wait();
         }
         Thread.sleep(1000);
         int i = (Integer) taskQueue.remove(0);
         System.out.println("Consumed: " + i);
         taskQueue.notifyAll();
      }
   }
}

Application

public class ProducerConsumerExampleWithWaitAndNotify
{
   public static void main(String[] args)
   {
      List taskQueue = new ArrayList();
      int MAX_CAPACITY = 5;
      Thread tProducer = new Thread(new Producer(taskQueue, MAX_CAPACITY), "Producer");
      Thread tConsumer = new Thread(new Consumer(taskQueue), "Consumer");
      tProducer.start();
      tConsumer.start();
   }
}
 
Output:
 
Produced: 0
Produced: 1
Produced: 2
Produced: 3
Produced: 4
Queue is full Producer is waiting , size: 5
Consumed: 0
Consumed: 1
Consumed: 2
Consumed: 3
Consumed: 4
Queue is empty Consumer is waiting , size: 0
Produced: 5
Produced: 6
Produced: 7
Produced: 8
Produced: 9
Queue is full Producer is waiting , size: 5
Consumed: 5
Consumed: 6
Consumed: 7
Consumed: 8
Consumed: 9
Queue is empty Consumer is waiting , size: 0
```
下班写完这些，感觉自己
![pkq.jpg](http://upload-images.jianshu.io/upload_images/3876169-33620787f86e68b0.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

Don't worry，be happy!
[传送门（代码地址）](https://github.com/ftc300/JavaLaboratory.git)以后做实验的java代码repo
参考资料：
官方Object说明文档：
https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html
stackoverflow :
http://stackoverflow.com/questions/886722/how-to-use-wait-and-notify-in-java
线程池 ExecutorService 执行完毕 ：
http://blog.csdn.net/truong/article/details/40227435
线程的wait/notify：
http://www.programcreek.com/2009/02/notify-and-wait-example/
how-to-work-with-wait-notify-and-notifyall-in-java :
http://howtodoinjava.com/core-java/multi-threading/how-to-work-with-wait-notify-and-notifyall-in-java/
![维护个公众号试试吧.png](http://upload-images.jianshu.io/upload_images/3876169-5d1963a40559aa03.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)