修改join示例代码

dypcoder · web-flow · commit 97178a8f69d4 · 2018-12-17T16:04:28.000+08:00
原po代码个人感觉有些歧义
diff --git a/2.线程的状态转换以及基本操作/线程状态转换以及基本操作.md b/2.线程的状态转换以及基本操作/线程状态转换以及基本操作.md
@@ -132,9 +132,9 @@ interrupted（）对当前线程进行中断操作，该方法会清除中断标
 ## 3.2.	join ##
 
 join方法可以看做是线程间协作的一种方式，很多时候，一个线程的输入可能非常依赖于另一个线程的输出，这就像两个好基友，一个基友先走在前面突然看见另一个基友落在后面了，这个时候他就会在原处等一等这个基友，等基友赶上来后，就两人携手并进。其实线程间的这种协作方式也符合现实生活。在软件开发的过程中，从客户那里获取需求后，需要经过需求分析师进行需求分解后，这个时候产品，开发才会继续跟进。如果一个线程实例A执行了threadB.join(),其含义是：当前线程A会等待threadB线程终止后threadA才会继续执行(**“主线程”等待“子线程”结束之后才能继续运行。**)。关于join方法一共提供如下这些方法:
-> public final synchronized void join(long millis)
-> public final synchronized void join(long millis, int nanos)
-> public final void join() throws InterruptedException
+> public final synchronized void join(long millis)</br>
+> public final synchronized void join(long millis, int nanos)</br>
+> public final void join() throws InterruptedException</br>
 
 Thread类除了提供join()方法外，另外还提供了超时等待的方法，如果线程threadB在等待的时间内还没有结束的话，threadA会在超时之后继续执行。join方法源码关键是：
 
@@ -144,48 +144,69 @@ Thread类除了提供join()方法外，另外还提供了超时等待的方法
 
 可以看出来当前等待对象threadA会一直阻塞，直到被等待对象threadB结束后即isAlive()返回false的时候才会结束while循环，当threadB退出时会调用notifyAll()方法通知所有的等待线程。下面用一个具体的例子来说说join方法的使用：
 
-	public class JoinDemo {
-	    public static void main(String[] args) {
-	        Thread previousThread = Thread.currentThread();
-	        for (int i = 0; i <= 10; i++) {
-	            Thread curThread = new JoinThread(previousThread);
-	            curThread.start();
-	            previousThread = curThread;
-	        }
-	    }
-	
-	    static class JoinThread extends Thread {
-	        private Thread thread;
-	
-	        public JoinThread(Thread thread) {
-	            this.thread = thread;
-	        }
-	
-	        @Override
-	        public void run() {
-	            try {
-	                thread.join();
-	                System.out.println(thread.getName() + " terminated.");
-	            } catch (InterruptedException e) {
-	                e.printStackTrace();
-	            }
-	        }
-	    }
-	}
+public class JoinDemo {
+    public static void main(String[] args) throws InterruptedException {
+        for (int i = 0; i <= 10; i++) {
+            MyThread thread = new MyThread();
+            thread.start();
+            try {
+                thread.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+            System.out.println("主线程执行完毕");
+            System.out.println("~~~~~~~~~~~~~~~");
+        }
+    }
+
+    static class MyThread extends Thread {
+        @Override
+        public void run() {
+            try {
+                Thread.sleep(1000);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+            System.out.println("子线程执行完毕");
+        }
+    }
+}
 
 输出结果为：
 
-> main terminated.
-> Thread-0 terminated.
-> Thread-1 terminated.
-> Thread-2 terminated.
-> Thread-3 terminated.
-> Thread-4 terminated.
-> Thread-5 terminated.
-> Thread-6 terminated.
-> Thread-7 terminated.
-> Thread-8 terminated.
-> Thread-9 terminated.
+子线程执行完毕
+主线程执行完毕
+~~~~~~~~~~~~~~~
+子线程执行完毕
+主线程执行完毕
+~~~~~~~~~~~~~~~
+子线程执行完毕
+主线程执行完毕
+~~~~~~~~~~~~~~~
+子线程执行完毕
+主线程执行完毕
+~~~~~~~~~~~~~~~
+子线程执行完毕
+主线程执行完毕
+~~~~~~~~~~~~~~~
+子线程执行完毕
+主线程执行完毕
+~~~~~~~~~~~~~~~
+子线程执行完毕
+主线程执行完毕
+~~~~~~~~~~~~~~~
+子线程执行完毕
+主线程执行完毕
+~~~~~~~~~~~~~~~
+子线程执行完毕
+主线程执行完毕
+~~~~~~~~~~~~~~~
+子线程执行完毕
+主线程执行完毕
+~~~~~~~~~~~~~~~
+子线程执行完毕
+主线程执行完毕
+~~~~~~~~~~~~~~~
 
 在上面的例子中一个创建了10个线程，每个线程都会等待前一个线程结束才会继续运行。可以通俗的理解成接力，前一个线程将接力棒传给下一个线程，然后又传给下一个线程......
 
