@@ -151,7 +151,10 @@ private boolean valid(int threshlod ,int x,int y){
 
 private int walk(int threshold,int startx,int starty){
     visited[startx][starty]=true;
-    int walks = 1;
+    int walks = 0;
+    if(valid(threshold,startx,starty)){
+        walks=1;
+    }
     for(int i=0;i<4;i++){
         int newX = startx+d[i][0];
         int newY = starty+d[i][1];
 
@@ -389,7 +389,7 @@ sleep() 和 wait() 的区别：
 
   sleep() 是 Thread 的静态方法；
 
-  wait() 是 Object 的常量方法，所以任何对象都可以调用 wait()
+  wait() 是 Object 的成员方法，所以任何对象都可以调用 wait()
 
 - 锁是否会释放
 
@@ -409,6 +409,10 @@ Thread.yield() 声明了当前线程已经完成了生命周期中最重要的
 
 yield() 和 wait() 的区别：
 
+- yield() 是 Thread 的静态方法
+
+  wait() 是 Object 的成员方法
+
 - yield() 让当前线程由“运行状态”进入“就绪状态”；
 
   wait() 让当前线程由“运行状态”进入“等待状态”
@@ -417,6 +421,16 @@ yield() 和 wait() 的区别：
 
   wait() 会释放同步锁，使得其他线程可以使用同步块或者同步方法
 
+### notify() 和 notifyAll()
+
+锁池：线程 A 已经拥有某个对象的锁，线程 B、C 想要调用这个对象的同步方法，此时线程 B、C 就会被阻塞，进入一个地方去等待锁的释放，这个地方就是该对象的锁池。
+
+等待池：假设线程 A 调用了某个对象的 wait() 方法，线程 A 释放该对象的锁，同时线程 A 进入等待池，进入等待池的线程不会竞争该对象的锁。
+
+**notifyAll() 让所有处于等待池的线程进入锁池去竞争锁**。
+
+
+
 ## 五、终止线程的几种方式
 
 ### 1. 退出标志
 
@@ -130,7 +130,7 @@ public static void main(String[] args) throws InterruptedException {
 
 - volatile，保证被 volatile 修饰的共享变量对所有线程总是可见的
 - synchronized，**对一个变量执行 unlock 操作之前，必须把变量值同步回主内存**。
-- final，被 final 关键字修饰的字段在构造器中一旦初始化完成，并且没有发生 this 逃逸（其它线程通过 this 引用访问到初始化了一半的对象），那么其它线程就能看见 final 字段的值。
+- final，被 final 关键字修饰的字段在构造器中一旦初始化完成，并且没有发生 this 逃逸（其它线程通过 this 引用访问到未初始化完成的对象），那么其它线程就能看见 final 字段的值。
 
 注意： volatile 并不能保证操作的原子性。
 
 
@@ -32,7 +32,7 @@ volatile 有 2 个主要功能：
 **线程安全问题**:
 
 - 存在共享数据（临界资源）
-- 存在多条线程共同操作这些共享数据操作共享数据
+- 存在多条线程共同操作这些共享数据
 
 解决：**同步机制**。
 
 
@@ -250,4 +250,28 @@ Hashtable 全表锁
 
 ConcurrentHashMap 分段锁
 
-![img](https://gitee.com/duhouan/ImagePro/raw/master/java-notes/java/16_00.jpg)
+![img](https://gitee.com/duhouan/ImagePro/raw/master/java-notes/java/16_00.jpg)
+
+# 补充
+
+## 红黑树性质
+
+1. 每个节点或者是红色的，或者是黑色的
+
+2. 根节点是黑色的
+
+3. 每一个叶子节点(最后的空节点)是黑色的
+
+   > 这其实是一个定义
+
+4. 如果一个节点是红色的，那么它们的孩子节点都是黑色的
+
+   > 因为红节点和其父亲节点表示一个3节点，黑色节点的右孩子一定是黑色节点。
+
+5. 从任意一个节点到叶子节点经过的**黑色节点**都是一样的
+
+   > 因为2-3树是绝对平衡的
+
+![img](https://gitee.com/duhouan/ImagePro/raw/master/java-notes/dataStructure/redBlackTree//12_11.png)
+
+相较于 AVL 树，**红黑树上的查找的操作的效率的低于 AVL 树的。但对于增删操作，红黑树的性能是更优的。**
@@ -96,31 +96,52 @@ Semaphore 类似于操作系统中的信号量，可以控制对互斥资源的
 
 ```java
 public class SemaphoreExample {
-
     public static void main(String[] args) {
-        final int clientCount = 3;
-        final int totalRequestCount = 10;
-        Semaphore semaphore = new Semaphore(clientCount);
-        ExecutorService executorService = Executors.newCachedThreadPool();
-        for (int i = 0; i < totalRequestCount; i++) {
-            executorService.execute(()->{
-                try {
-                    semaphore.acquire();
-                    System.out.print(semaphore.availablePermits() + " ");
-                } catch (InterruptedException e) {
-                    e.printStackTrace();
-                } finally {
-                    semaphore.release();
+        final int threadNum=1;
+        final int totalThread=10;
+
+        Semaphore semaphore=new Semaphore(threadNum);
+
+        ExecutorService service= Executors.newCachedThreadPool();
+
+        for(int i=0;i<totalThread;i++){
+            final int num=i;
+            service.execute(new Runnable() {
+                @Override
+                public void run() {
+                    try {
+                        semaphore.acquire();
+                        test(num);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }finally {
+                        semaphore.release();
+                    }
                 }
             });
         }
-        executorService.shutdown();
+        service.shutdown();
+    }
+
+    private static void test(int i) throws InterruptedException {
+        System.out.println("Thread: "+i);
+        Thread.sleep(1000);
     }
 }
 ```
 
 ```html
-2 1 2 2 2 2 2 1 2 2
+// 每隔一秒钟出现一次
+Thread: 0
+Thread: 1
+Thread: 2
+Thread: 3
+Thread: 4
+Thread: 5
+Thread: 7
+Thread: 6
+Thread: 8
+Thread: 9
 ```
 
 ### 4. CountDownLatch 和 CyclicBarrier 比较
@@ -217,51 +238,67 @@ java.util.concurrent.BlockingQueue 接口有以下阻塞队列的实现：
 
 ```java
 public class ProducerConsumer {
+    private static BlockingQueue<String> queue=new LinkedBlockingQueue<>();
 
-    private static BlockingQueue<String> queue = new ArrayBlockingQueue<>(5);
-
-    private static class Producer extends Thread {
+    private static class Producer extends Thread{
         @Override
         public void run() {
             try {
                 queue.put("product");
+                System.out.println("produce...");
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
-            System.out.print("produce..");
         }
     }
 
-    private static class Consumer extends Thread {
-
+    private static class Consumer extends Thread{
         @Override
         public void run() {
             try {
-                String product = queue.take();
+                queue.take();
+                System.out.println("consume...");
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
-            System.out.print("consume..");
         }
     }
-}Copy to clipboardErrorCopied
-public static void main(String[] args) {
-    for (int i = 0; i < 2; i++) {
-        Producer producer = new Producer();
-        producer.start();
-    }
-    for (int i = 0; i < 5; i++) {
-        Consumer consumer = new Consumer();
-        consumer.start();
-    }
-    for (int i = 0; i < 3; i++) {
-        Producer producer = new Producer();
-        producer.start();
+
+    public static void main(String[] args) {
+        for(int i=0;i<2;i++){
+            Producer p=new Producer();
+            p.start();
+        }
+
+        for(int i=0;i<5;i++){
+            Consumer c=new Consumer();
+            c.start();
+        }
+
+        for(int i=0;i<3;i++){
+            Producer p=new Producer();
+            p.start();
+        }
+
     }
-}Copy to clipboardErrorCopied
-produce..produce..consume..consume..produce..consume..produce..consume..produce..consume..Copy to clipboardErrorCopied
+}
+```
+
+```html
+produce...
+produce...
+consume...
+consume...
+produce...
+produce...
+consume...
+consume...
+produce...
+consume...
 ```
 
+
+
 ### 3. ForkJoin
 
 主要用于并行计算中，和 MapReduce 原理类似，都是把大的计算任务拆分成多个小任务并行计算。