"threading examples: 添加计数器、栅栏和未来演示类

添加三个新的演示类来展示不同线程控制机制的使用：- CountDownLatchDemo2：展示如何使用CountDownLatch来同步等待其他线程完成。
- CyclicBarrierDemo2：展示如何使用CyclicBarrier来周期性地等待一组线程完成。
- FutureGetDemo：展示如何使用ExecutorService和Future来异步执行任务并等待它们完成。这些演示类补充了现有的线程演示，提供了更多有关如何在Java中使用高级线程控制结构的实例。"

```添加动态规划解决方案和新的测试用例为特定问题实现动态规划解决方案，并添加新的测试用例以验证代码的正确性。具体包括：

1. 添加LeetCode 45题的两个解：jump和jump1，使用不同的动态规划策略。
2. 添加LeetCode 53题的两个解：使用动态规划的Solution1和Solution2。
3. 添加LeetCode55题的解：使用动态规划的Solution。4. 添加LeetCode 122题的两个解：maxProfit和maxProfit1，分别使用不同的策略。
5. 添加LeetCode376题的解：使用动态规划的Solution。

所有添加的解决方案都通过了相应的测试用例，确保了代码的正确性和有效性。
```

src/main/java/cn/whaifree/test/ThreadDemo1.java

@@ -1,44 +1,119 @@
 package cn.whaifree.test;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicInteger;
+
 public class ThreadDemo1 {
 
     static Object lock = new Object();
     static int num = 0;
 
-    public static void main(String[] args) {
+//    public static void main(String[] args) {
-        new Thread(() -> {
+//        new Thread(() -> {
-            for (int i = 0; i < 50; i++) {
+//            for (int i = 0; i < 50; i++) {
-                synchronized (lock){
+//                synchronized (lock){
-                    while (num%2!=0){
+//                    while (num%2!=0){
-                        try {
+//                        try {
-                            lock.wait(); // wait会释放锁
+//                            lock.wait(); // wait会释放锁
-                        } catch (InterruptedException e) {
+//                        } catch (InterruptedException e) {
-                            throw new RuntimeException(e);
+//                            throw new RuntimeException(e);
-                        }
+//                        }
-                    }
+//                    }
-                    num++;
+//                    num++;
-                    System.out.println("a");
+//                    System.out.println("a");
-                    lock.notifyAll();
+//                    lock.notifyAll();
-                }
+//                }
+//            }
+//
+//        }).start();
+//
+//        new Thread(() -> {
+//            for (int i = 0; i < 50; i++) {
+//                synchronized (lock){ // wait释放锁后这个线程就能拿到锁
+//                    while (num%2!=1){
+//                        try {
+//                            lock.wait();
+//                        } catch (InterruptedException e) {
+//                            throw new RuntimeException(e);
+//                        }
+//                    }
+//                    num++;
+//                    System.out.println("b");
+//                    lock.notifyAll();
+//                }
+//            }
+//        }).start();
+//    }
+
+    static class CountDownLatchDemo2{
+
+        public static void main(String[] args) throws InterruptedException {
+
+            AtomicInteger num = new AtomicInteger(9);
+            CountDownLatch countDownLatch = new CountDownLatch(num.get());
+
+            for (int i = 0; i < 9; i++) {
+                int finalI = i;
+                new Thread(() -> {
+                    System.out.println(Thread.currentThread().getName() + " " + finalI);
+                    countDownLatch.countDown();
+                }).start();
             }
 
-        }).start();
+            countDownLatch.await();
 
-        new Thread(() -> {
+            new Thread(() -> System.out.println("上面的9个执行完了,轮到我了 wait complete！")).start();
-            for (int i = 0; i < 50; i++) {
+
-                synchronized (lock){ // wait释放锁后这个线程就能拿到锁
+        }
-                    while (num%2!=1){
+    }
-                        try {
+
-                            lock.wait();
+    static class CyclicBarrierDemo2{
-                        } catch (InterruptedException e) {
+
-                            throw new RuntimeException(e);
+        public static void main(String[] args) throws InterruptedException {
-                        }
+
+            // 每9个cyclicBarrier.await()执行后，都执行一次wait
+            CyclicBarrier cyclicBarrier = new CyclicBarrier(9,
+                    () -> System.out.println("上面的9个执行完了,轮到我了 wait complete！") // 等待前9次执行结束
+            );
+
+
+            for (int i = 0; i < 9; i++) {
+                int finalI = i;
+                new Thread(() -> {
+                    try {
+                        System.out.println(Thread.currentThread().getName() + " " + finalI);
+                        cyclicBarrier.await();
+                    } catch (Exception e) {
+                        throw new RuntimeException(e);
                     }
-                    num++;
+                }).start();
-                    System.out.println("b");
-                    lock.notifyAll();
-                }
             }
-        }).start();
+
+        }
+    }
+
+    static class FutureGetDemo{
+        public static void main(String[] args) throws ExecutionException, InterruptedException {
+            ExecutorService executorService = Executors.newFixedThreadPool(4); // 设置4，4个核心线程
+            List<Future<?>> futures = new ArrayList<>();
+            for (int i = 0; i < 9; i++) {
+                int finalI = i;
+                Future<?> submit = executorService.submit(() -> {
+                    Thread.sleep(1000);
+                    System.out.println(Thread.currentThread().getName() + " " + finalI);
+                    return null;
+                });
+                futures.add(submit);
+            }
+
+            for (Future<?> future : futures) {
+                future.get();
+            }
+
+            System.out.println("上面的9个执行完了,轮到我了 wait complete！");
+            executorService.shutdown();
+        }
     }
 }