进阶day06-线程池：处理runnable任务

javaSE-day06/src/com/inmind/thread_pool10/Demo10.java

@@ -0,0 +1,44 @@
+package com.inmind.thread_pool10;
+
+import java.util.concurrent.*;
+
+/*
+在java中使用一个接口表示线程池ExecutorService
+
+如何获取线程池对象？？
+方式一：直接创建实现类ThreadPoolExecutor 的对象
+方式二：Executors（线程池）的静态方法
+
+方式一的构造方法：
+ThreadPoolExecutor(
+     int corePoolSize,
+     int maximumPoolSize,
+     long keepAliveTime,
+     TimeUnit unit,
+     BlockingQueue<Runnable> workQueue,
+     ThreadFactory threadFactory,
+     RejectedExecutionHandler handler)
+
+参数一：corePoolSize，指定线程池核心线程的数量
+参数二：maximumPoolSize，指定线程池的最大线程数量
+参数三：keepAliveTime，指定临时线程的存活时间
+参数四：unit，指定临时线程存活时间单位（秒，分，时，天）
+参数五：workQueue 指定线程池的任务队列
+参数六：threadFactory，指定线程池的线程工厂
+参数七：handler，指定线程池的任务拒绝策略
+ */
+public class Demo10 {
+    public static void main(String[] args) {
+        //使用多态创建线程池
+        ExecutorService threadPool = new ThreadPoolExecutor(
+                3,
+                5,
+                8,
+                TimeUnit.SECONDS,
+                new ArrayBlockingQueue<>(4),
+                Executors.defaultThreadFactory(),
+                new ThreadPoolExecutor.AbortPolicy());
+
+        System.out.println("程序程序");
+    }
+}

javaSE-day06/src/com/inmind/thread_pool10/Demo11.java

@@ -0,0 +1,63 @@
+package com.inmind.thread_pool10;
+
+import java.util.concurrent.*;
+
+/*
+学习内容：线程池：处理runnable任务
+
+常用的API
+void execute(Runnable command) 在将来某个时候执行给定的任务。
+<T> Future<T> submit(Callable<T> task) 提交值返回任务以执行，并返回代表任务待处理结果的Future。
+void shutdown() 启动有序关闭，其中先前提交的任务将被执行，但不会接受任何新任务。
+List<Runnable> shutdownNow() 尝试停止所有主动执行的任务，停止等待任务的处理，并返回正在等待执行的任务列表。
+
+注意：
+    1.临时线程什么时候会创建？？
+    新任务提交到线程池，发现所有的核心线程都被占用，任务队列也满了，并且还可以创建临时线程时，才会创建新的临时线程
+    2.什么时候会开始拒绝任务？？？
+    当所有的核心线程和临时线程都在忙，而且任务队列也都满了，新的任务还来，线程池就开始拒绝任务
+---------------------------------------
+线程池超负荷运行任务策略：
+AbortPolicy：当线程池添加超负荷任务时，直接抛异常（默认策略）
+DiscardOldestPolicy：丢弃任务，但不抛异常，不推荐
+CallerRunsPolicy：由主线程负责调用任务的run方法
+DiscardPolicy：也是直接丢弃
+ */
+public class Demo11 {
+    public static void main(String[] args) {
+        //使用多态创建线程池对象
+        ExecutorService threadPool = new ThreadPoolExecutor(
+                3,
+                5,
+                8,
+                TimeUnit.SECONDS,
+                new ArrayBlockingQueue<>(4),
+                Executors.defaultThreadFactory(),
+                new ThreadPoolExecutor.DiscardPolicy());
+
+        //创建出任务
+        MyRunnable task = new MyRunnable();
+
+        //将任务交给线程池处理
+        threadPool.execute(task);
+        threadPool.execute(task);
+        threadPool.execute(task);
+        //核心线程占满，将任务放入到任务队列
+        threadPool.execute(task);
+        threadPool.execute(task);
+        threadPool.execute(task);
+        threadPool.execute(task);
+        //线程任务长时间占用3个核心线程，4个任务队列也排满了，此时创建临时线程2个
+        threadPool.execute(task);
+        threadPool.execute(task);
+        //所有的核心线程和临时线程都在忙，而且任务队列也都满了,如果还来任务，就要执行对应的策略
+        threadPool.execute(task);
+
+        System.out.println("程序结束");
+
+        //将线程池关闭
+//        threadPool.shutdown();//启动有序关闭，其中先前提交的任务将被执行，但不会再接收新的任务
+        threadPool.shutdownNow();//尝试停止所有正在执行的任务，并返回正在等待执行的任务列表
+    }
+
+}

javaSE-day06/src/com/inmind/thread_pool10/MyRunnable.java

@@ -0,0 +1,13 @@
+package com.inmind.thread_pool10;
+
+public class MyRunnable implements Runnable{
+    @Override
+    public void run() {
+        System.out.println(Thread.currentThread().getName()+"执行了任务");
+        try {
+            Thread.sleep(100000);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

javaSE-day06/src/com/inmind/thread_state09/Demo09.java

@@ -0,0 +1,20 @@
+package com.inmind.thread_state09;
+/*
+线程状态。 线程可以处于以下状态之一：
+NEW
+1.新建状态 new Thread(),创建线程对象时
+RUNNABLE
+2.运行状态 thread.start()线程启动就是运行状态
+BLOCKED
+3.阻塞状态：遇到synchronized关键字，还没有锁对象，线程就处于阻塞状态
+WAITING
+4.无限等待状态：当一个线程必须等着其他线程去唤醒，这就是无限等待状态(wait)
+TIMED_WAITING
+5.计时等待：当一个线程，等着时间到了，之后立马开始运行，这就是计时等待状态(sleep)
+TERMINATED
+6.结束状态:
+    1.线程正常执行完毕，就是结束状态
+    2.线程非正常执行完毕，stop方法
+ */
+public class Demo09 {
+}