add

Author: CodePrometheus

Lock/src/ReadWriteLock.java

@@ -1,5 +1,8 @@
 /**
  * 要么多读，要么一写
+ * <p>
+ * 注意！
+ * 读读共享、其他都互斥(写写互斥、读写互斥、写读互斥)
  *
  * @Author: zzStar
  * @Date: 10-09-2020 18:40

README.md

@@ -60,6 +60,13 @@ Java并发编程
     不可变性
     栈封闭
 
+## 并发容器
+    ConcurrentHashMap
+    CopyOnWriteArrayList
+    并发队列
+        阻塞队列
+        非阻塞队列
+    
 
 
         

Thread/src/threadpool/ShutDown.java

@@ -0,0 +1,44 @@
+package threadpool;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * 关闭线程池
+ *
+ * @Author: zzStar
+ * @Date: 10-12-2020 13:48
+ */
+public class ShutDown {
+    public static void main(String[] args) throws InterruptedException {
+        ExecutorService executorService = Executors.newFixedThreadPool(10);
+        for (int i = 0; i < 50; i++) {
+            executorService.execute(new ShutDownTask());
+        }
+        Thread.sleep(1000);
+//        System.out.println("executorService.awaitTermination(3L, TimeUnit.SECONDS) = " + executorService.awaitTermination(3L, TimeUnit.SECONDS));
+//        System.out.println("executorService.isShutdown() = " + executorService.isShutdown());
+//        executorService.shutdown();
+//        System.out.println("executorService.isShutdown() = " + executorService.isShutdown());
+//        System.out.println("executorService.isTerminated() = " + executorService.isTerminated());
+//        System.out.println("==========");
+//        Thread.sleep(2000);
+//        System.out.println("executorService.isTerminated() = " + executorService.isTerminated());
+//        executorService.execute(new ShutDownTask());RejectedExecutionException
+        executorService.shutdownNow();//可得到未执行的线程数组
+    }
+}
+
+class ShutDownTask implements Runnable {
+    @Override
+    public void run() {
+        try {
+            Thread.sleep(500);
+            System.out.println(Thread.currentThread().getName());
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+            System.out.println(Thread.currentThread().getName() + "被中断了");
+        }
+    }
+}

Thread/src/threadpool/ThreadPoolAnalysis.java

@@ -0,0 +1,132 @@
+package threadpool;
+
+/**
+ * 线程池分析
+ *
+ * @Author: zzStar
+ * @Date: 10-12-2020 14:07
+ */
+public class ThreadPoolAnalysis {
+
+    /**
+     * 线程池的组分部分：
+     *      线程池管理器
+     *      工作线程
+     *      任务队列（blocking queue）
+     *      任务接口（Task）
+     */
+
+    /**
+     * Executor <- ExecutorService <- AbstractExecutorService <- ThreadPoolExecutor
+     */
+
+    /**
+     * 线程池实现任务复用的原理
+     *      相同线程执行不同的任务，线程池是让固定的线程不断地从队列中取出任务并执行
+     */
+
+    /**
+     * 线程池五种状态
+     * RUNNING
+     * SHUTDOWN 不接受新任务，但处理排队任务
+     * STOP
+     * TIDYING 所有任务都终止，workerCount为0时，线程会转到TIDYING状态，并将运行terminate()钩子方法
+     * TERMINATED terminate()运行完成
+     */
+
+    /**
+     * 使用线程池注意点：
+     *      避免任务堆积
+     *      避免线程数过度增加
+     *      排查线程泄露（线程回收不了，任务逻辑可能出问题）
+     */
+}
+/*
+    public void execute(Runnable command) {
+        if (command == null)
+            throw new NullPointerException();
+        */
+/*
+         * Proceed in 3 steps:
+         *
+         * 1. If fewer than corePoolSize threads are running, try to
+         * start a new thread with the given command as its first
+         * task.  The call to addWorker atomically checks runState and
+         * workerCount, and so prevents false alarms that would add
+         * threads when it shouldn't, by returning false.
+         *
+         * 2. If a task can be successfully queued, then we still need
+         * to double-check whether we should have added a thread
+         * (because existing ones died since last checking) or that
+         * the pool shut down since entry into this method. So we
+         * recheck state and if necessary roll back the enqueuing if
+         * stopped, or start a new thread if there are none.
+         *
+         * 3. If we cannot queue task, then we try to add a new
+         * thread.  If it fails, we know we are shut down or saturated
+         * and so reject the task.
+         *//*
+
+        //ctl记录了线程状态和线程数
+        int c = ctl.get();
+        //少于则创建一个线程
+        if (workerCountOf(c) < corePoolSize) {
+            //任务command
+            if (addWorker(command, true))
+                return;
+            c = ctl.get();
+        }
+        // >=corePoolSize,先放入工作队列中
+        if (isRunning(c) && workQueue.offer(command)) {
+            int recheck = ctl.get();
+            if (! isRunning(recheck) && remove(command))
+                reject(command);
+            //防止任务提交却没有线程来执行
+            else if (workerCountOf(recheck) == 0)
+                addWorker(null, false);
+        }
+        else if (!addWorker(command, false))
+            reject(command);
+    }
+
+    final void runWorker(Worker w) {
+        Thread wt = Thread.currentThread();
+        Runnable task = w.firstTask;
+        w.firstTask = null;
+        w.unlock(); // allow interrupts
+        boolean completedAbruptly = true;
+        try {
+            //work不会停止
+            while (task != null || (task = getTask()) != null) {
+                w.lock();
+                // If pool is stopping, ensure thread is interrupted;
+                // if not, ensure thread is not interrupted.  This
+                // requires a recheck in second case to deal with
+                // shutdownNow race while clearing interrupt
+                if ((runStateAtLeast(ctl.get(), STOP) ||
+                     (Thread.interrupted() &&
+                      runStateAtLeast(ctl.get(), STOP))) &&
+                    !wt.isInterrupted())
+                    wt.interrupt();
+                try {
+                    beforeExecute(wt, task);
+                    try {
+                        task.run();
+                        afterExecute(task, null);
+                    } catch (Throwable ex) {
+                        afterExecute(task, ex);
+                        throw ex;
+                    }
+                } finally {
+                    task = null;
+                    w.completedTasks++;
+                    w.unlock();
+                }
+            }
+            completedAbruptly = false;
+        } finally {
+            processWorkerExit(w, completedAbruptly);
+        }
+    }
+*/
+