Important Method

Author: CodePrometheus

README.md

@@ -6,6 +6,8 @@ Java并发编程
      创建线程的两种方法
      正确启动线程
      正确停止线程
+     线程六大生命周期
+     Thread和Object中的重要方法
      ThreadPool
      ThreadLocal
 

Thread/src/importantmethod/MethodSummary.java

@@ -0,0 +1,59 @@
+package importantmethod;
+
+/**
+ * @Author: zzStar
+ * @Date: 10-17-2020 14:56
+ */
+public class MethodSummary {
+
+    /**
+     * wait,notify,notifyAll
+     *  1.用必须先拥有monitor
+     *  2.只能唤醒其中一个，取决于jvm的实现
+     *  3.都属于Object类，任何对象都可以调用，native final
+     *  4.类似功能的Condition
+     *  5.同时持有多个锁的情况，释放现在wait所对应的对象的那把锁，注意避免死锁的发生
+     */
+
+    /**
+     * 特殊情况注意 ❗
+     *     -> 从Object.wait()状态刚被唤醒时，通常不能立刻抢到monitor锁，（因为其他线程唤醒也需要持有同一把锁）
+     *           那就会从waiting先进入blocked状态，抢到锁后再转换到Runnable状态
+     *     -> 如果发生异常，可以直接跳转到终止Terminated状态，不必再遵循路径，比如可以从waiting直接到Terminated
+     */
+
+    /**
+     * wait()需要放在同步代码块里面执行的原因是为了让通信变得可靠，防止死锁、永久等待的发生
+     * 线程间需要协同配合的方式放入同步代码块中实现
+     */
+
+    /**
+     * 为什么wait,notify,notifyAll被定义在Object里面？
+     *      ->锁级别的操作，属于对象，而非线程中
+     *      ->Thread.wait，线程退出的时候，源码中会自动notify
+     */
+
+    /**
+     *  Sleep ❗ 方法可以让线程进入waiting状态，并且不占用CPU资源，但是不释放锁，
+     *   直到规定时间后再执行，休眠期间如果被中断，会抛出异常并清除中断状态
+     */
+
+    /**
+     * wait ，notify ，sleep 异同
+     *      -> 相同 1.阻塞
+     *             2.响应中断
+     *
+     *      -> 不同 1.wait ，notify必须在同步方法（见上述原因）
+     *              2.Sleep不释放锁
+     *              3.sleep要指定时间，wait不传则直到自己被唤醒
+     *              4.所属类不同（见上述原因）
+     */
+
+    /**
+     *  join 期间，线程处于waiting的状态
+     */
+
+    /**
+     * yield释放CPU时间片，但不释放锁，也不会陷入阻塞，仍然Runnable
+     */
+}

Thread/src/importantmethod/join/JoinInterrupt.java

@@ -0,0 +1,37 @@
+package importantmethod.join;
+
+/**
+ * join期间被中断
+ *
+ * @Author: zzStar
+ * @Date: 10-18-2020 12:30
+ */
+public class JoinInterrupt {
+    public static void main(String[] args) {
+        Thread mainThread = Thread.currentThread();
+        Thread thread = new Thread(() -> {
+            try {
+                // 中断主线程
+                mainThread.interrupt();
+                Thread.sleep(2000);
+                System.out.println("Thread1 finished");
+            } catch (InterruptedException e) {
+//                e.printStackTrace();
+                System.out.println("子线程中断");
+            }
+        });
+
+        thread.start();
+        System.out.println("等待子线程运行完毕");
+        try {
+            // 但主线程在等待子线程
+            thread.join();
+        } catch (InterruptedException e) {
+            System.out.println(Thread.currentThread().getName() + "主线程被中断了");
+//            e.printStackTrace();
+            thread.interrupt();
+        }
+        // 注意，子线程根本就没有运行完毕，仍继续打出Thread1 finished
+        System.out.println("子线程执行完毕");
+    }
+}

Thread/src/importantmethod/join/JoinPrinciple.java

@@ -0,0 +1,33 @@
+package importantmethod.join;
+
+/**
+ * 通过join原理，分析出join的代替写法
+ *
+ * @Author: zzStar
+ * @Date: 10-18-2020 13:03
+ */
+public class JoinPrinciple {
+
+    public static void main(String[] args) throws InterruptedException {
+        Thread thread1 = new Thread(() -> {
+            try {
+                Thread.sleep(1000);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+            System.out.println(Thread.currentThread().getName() + "执行完毕");
+        });
+
+        thread1.start();
+        System.out.println("开始等待子线程运行完毕");
+//        thread1.join();
+
+        // 等价代码
+        synchronized (thread1) {
+            // 直到thread1执行完毕才继续
+            thread1.wait();
+        }
+        System.out.println("所有子线程全部执行完毕");
+    }
+
+}

Thread/src/importantmethod/join/JoinThreadState.java

@@ -0,0 +1,27 @@
+package importantmethod.join;
+
+/**
+ * join线程状态
+ *
+ * @Author: zzStar
+ * @Date: 10-18-2020 12:48
+ */
+public class JoinThreadState {
+    public static void main(String[] args) throws InterruptedException {
+        Thread mainThread = Thread.currentThread();
+
+        Thread thread = new Thread(() -> {
+            try {
+                Thread.sleep(3000);
+                System.out.println(mainThread.getState());//WAITING
+                System.out.println("Thread-0运行结束🔚");
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        });
+        thread.start();
+        System.out.println("等待子线程运行完毕");
+        thread.join();// 主线程等待
+        System.out.println("子线程运行完毕");
+    }
+}

Thread/src/importantmethod/join/JoinUsage.java

@@ -0,0 +1,38 @@
+package importantmethod.join;
+
+/**
+ * 新的线程加入了，要等待它执行完再出发
+ *
+ * @Author: zzStar
+ * @Date: 10-18-2020 12:11
+ */
+public class JoinUsage {
+
+    public static void main(String[] args) throws InterruptedException {
+        Thread thread1 = new Thread(() -> {
+            try {
+                Thread.sleep(1000);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+            System.out.println(Thread.currentThread().getName() + "执行完毕");
+        });
+
+        Thread thread2 = new Thread(() -> {
+            try {
+                Thread.sleep(1000);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+            System.out.println(Thread.currentThread().getName() + "执行完毕");
+        });
+
+        thread1.start();
+        thread2.start();
+        System.out.println("开始等待子线程运行完毕");
+        //使得主线程main等待其执行完毕
+        thread1.join();
+        thread2.join();
+        System.out.println("所有子线程全部执行完毕");
+    }
+}

Thread/src/importantmethod/methods.png

@@ -0,0 +1,34 @@
+package importantmethod.sleep;
+
+import java.util.Date;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * 实现每一秒钟输出当前时间，被中断，观察
+ *
+ * @Author: zzStar
+ * @Date: 10-18-2020 11:18
+ */
+public class SleepInterrupted implements Runnable {
+
+    public static void main(String[] args) throws InterruptedException {
+        SleepInterrupted sleepInterrupted = new SleepInterrupted();
+        Thread thread = new Thread(sleepInterrupted);
+        thread.start();
+        Thread.sleep(5000);
+        thread.interrupt();
+    }
+
+    @Override
+    public void run() {
+        for (int i = 0; i < 10; i++) {
+            System.out.println(new Date());
+            try {
+                TimeUnit.SECONDS.sleep(1);
+            } catch (InterruptedException e) {
+                System.out.println("被中断");
+                e.printStackTrace();
+            }
+        }
+    }
+}

Thread/src/importantmethod/sleep/SleepInterrupted.java

@@ -0,0 +1,34 @@
+package importantmethod.sleep;
+
+/**
+ * 1.让线程在预期的时间执行，其他时候不要占用cpu资源
+ * 2.不释放锁
+ *
+ * @Author: zzStar
+ * @Date: 10-17-2020 16:31
+ */
+public class SleepUsage implements Runnable {
+
+    public static void main(String[] args) {
+        SleepUsage sleepUsage = new SleepUsage();
+        Thread thread1 = new Thread(sleepUsage);
+        Thread thread2 = new Thread(sleepUsage);
+        thread1.start();
+        thread2.start();
+    }
+
+    @Override
+    public void run() {
+        syn();
+    }
+
+    private synchronized void syn() {
+        System.out.println(Thread.currentThread().getName() + "获取到了monitor");
+        try {
+            Thread.sleep(2000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        System.out.println(Thread.currentThread().getName() + "退出了同步代码块");
+    }
+}

Thread/src/importantmethod/sleep/SleepUsage.java

@@ -0,0 +1,91 @@
+package importantmethod.waitnotify;
+
+import java.util.Date;
+import java.util.LinkedList;
+
+/**
+ * 用wait/notify实现生产消费交替进行
+ *
+ * @Author: zzStar
+ * @Date: 10-17-2020 15:28
+ */
+public class ProducerConsumerModel {
+
+    public static void main(String[] args) {
+        EventStorage eventStorage = new EventStorage();
+        Producer producer = new Producer(eventStorage);
+        Consumer consumer = new Consumer(eventStorage);
+        new Thread(producer).start();
+        new Thread(consumer).start();
+    }
+}
+
+class Producer implements Runnable {
+    private EventStorage storage;
+
+    public Producer(EventStorage storage) {
+        this.storage = storage;
+    }
+
+    @Override
+    public void run() {
+        for (int i = 0; i < 100; i++) {
+            storage.put();
+        }
+    }
+}
+
+class Consumer implements Runnable {
+    private EventStorage storage;
+
+    public Consumer(EventStorage storage) {
+        this.storage = storage;
+    }
+
+
+    @Override
+    public void run() {
+        for (int i = 0; i < 100; i++) {
+            storage.take();
+        }
+    }
+}
+
+class EventStorage {
+    private int maxSize;
+    private LinkedList<Date> storage;
+
+    public EventStorage() {
+        maxSize = 10;
+        storage = new LinkedList<>();
+    }
+
+    public synchronized void put() {
+        while (storage.size() == maxSize) {
+            try {
+                wait();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+        storage.add(new Date());
+        System.out.println("仓库里有了" + storage.size() + "个产品");
+        //唤醒消费者
+        notify();
+    }
+
+    public synchronized void take() {
+        while (storage.size() == 0) {
+            try {
+                wait();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+//            System.out.println("拿到了" + storage.get(0) + ",现在仓库还剩下" + storage.size());
+//            storage.remove(0);
+        System.out.println("拿到了" + storage.poll() + ",现在仓库还剩下" + storage.size());
+        notify();
+    }
+}
+