Merge pull request frank-lam#15 from LimitSY/master

frank-lam · web-flow · commit c6e15c7ceada · 2018-11-12T09:32:13.000+08:00
code format
diff --git a/notes/JavaArchitecture/03 Java 并发编程.md b/notes/JavaArchitecture/03 Java 并发编程.md
@@ -1109,13 +1109,58 @@ public CountDownLatch(int count) {  };  // 参数count为计数值
 然后下面这 3 个方法是 CountDownLatch 类中最重要的方法：
 
 ```java
-`public` `void` `await() ``throws` `InterruptedException { };   ``//调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行``public` `boolean` `await(``long` `timeout, TimeUnit unit) ``throws` `InterruptedException { };  ``//和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行``public` `void` `countDown() { };  ``//将count值减1`
+//调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行
+public void await() throws InterruptedException { };
+//和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行
+public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };
+//将count值减1
+public void countDown() { };
 ```
 
 下面看一个例子大家就清楚 CountDownLatch 的用法了：
 
 ```java
-`public` `class` `Test {``     ``public` `static` `void` `main(String[] args) {   ``         ``final` `CountDownLatch latch = ``new` `CountDownLatch(``2``);``         ` `         ``new` `Thread(){``             ``public` `void` `run() {``                 ``try` `{``                     ``System.out.println(``"子线程"``+Thread.currentThread().getName()+``"正在执行"``);``                    ``Thread.sleep(``3000``);``                    ``System.out.println(``"子线程"``+Thread.currentThread().getName()+``"执行完毕"``);``                    ``latch.countDown();``                ``} ``catch` `(InterruptedException e) {``                    ``e.printStackTrace();``                ``}``             ``};``         ``}.start();``         ` `         ``new` `Thread(){``             ``public` `void` `run() {``                 ``try` `{``                     ``System.out.println(``"子线程"``+Thread.currentThread().getName()+``"正在执行"``);``                     ``Thread.sleep(``3000``);``                     ``System.out.println(``"子线程"``+Thread.currentThread().getName()+``"执行完毕"``);``                     ``latch.countDown();``                ``} ``catch` `(InterruptedException e) {``                    ``e.printStackTrace();``                ``}``             ``};``         ``}.start();``         ` `         ``try` `{``             ``System.out.println(``"等待2个子线程执行完毕..."``);``            ``latch.await();``            ``System.out.println(``"2个子线程已经执行完毕"``);``            ``System.out.println(``"继续执行主线程"``);``        ``} ``catch` `(InterruptedException e) {``            ``e.printStackTrace();``        ``}``     ``}``}`
+public class Test {
+    public static void main(String[] args) {
+        final CountDownLatch latch = new CountDownLatch(2);
+        new Thread() {
+            public void run() {
+                try {
+                    System.out.println("子线程" + Thread.currentThread().getName() + "正在执行");
+                    Thread.sleep(3000);
+                    System.out.println("子线程" + Thread.currentThread().getName() + "执行完毕");
+                    latch.countDown();
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+
+            ;
+        }.start();
+        new Thread() {
+            public void run() {
+                try {
+                    System.out.println("子线程" + Thread.currentThread().getName() + "正在执行");
+                    Thread.sleep(3000);
+                    System.out.println("子线程" + Thread.currentThread().getName() + "执行完毕");
+                    latch.countDown();
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+
+            ;
+        }.start();
+        try {
+            System.out.println("等待2个子线程执行完毕...");
+            latch.await();
+            System.out.println("2个子线程已经执行完毕");
+            System.out.println("继续执行主线程");
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+}
 ```
 
 执行结果：
@@ -1182,13 +1227,28 @@ Semaphore 就是操作系统中的信号量，可以控制对互斥资源的访
 Semaphore 类位于 java.util.concurrent 包下，它提供了2个构造器：
 
 ```java
-`public` `Semaphore(``int` `permits) {          ``//参数permits表示许可数目，即同时可以允许多少线程进行访问``    ``sync = ``new` `NonfairSync(permits);``}``public` `Semaphore(``int` `permits, ``boolean` `fair) {    ``//这个多了一个参数fair表示是否是公平的，即等待时间越久的越先获取许可``    ``sync = (fair)? ``new` `FairSync(permits) : ``new` `NonfairSync(permits);``}`
+public Semaphore(int permits) {          
+    //参数permits表示许可数目，即同时可以允许多少线程进行访问
+    sync = new NonfairSync(permits);
+}
+
+public Semaphore(int permits, boolean fair) {    
+    //这个多了一个参数fair表示是否是公平的，即等待时间越久的越先获取许可    
+    sync = (fair) ? new FairSync(permits) : new NonfairSync(permits);
+}
 ```
 
 下面说一下 Semaphore 类中比较重要的几个方法，首先是 acquire()、release() 方法：
 
 ```java
-`public` `void` `acquire() ``throws` `InterruptedException {  }     ``//获取一个许可``public` `void` `acquire(``int` `permits) ``throws` `InterruptedException { }    ``//获取permits个许可``public` `void` `release() { }          ``//释放一个许可``public` `void` `release(``int` `permits) { }    ``//释放permits个许可`
+//获取一个许可
+public void acquire() throws InterruptedException {  }
+//获取permits个许可
+public void acquire(int permits) throws InterruptedException { }
+//释放一个许可
+public void release() { }
+//释放permits个许可
+public void release(int permits) { }
 ```
 
 　　acquire() 用来获取一个许可，若无许可能够获得，则会一直等待，直到获得许可。
@@ -1198,7 +1258,14 @@ Semaphore 类位于 java.util.concurrent 包下，它提供了2个构造器：
 这 4 个方法都会被阻塞，如果想立即得到执行结果，可以使用下面几个方法：
 
 ```java
-`public` `boolean` `tryAcquire() { };    ``//尝试获取一个许可，若获取成功，则立即返回true，若获取失败，则立即返回false``public` `boolean` `tryAcquire(``long` `timeout, TimeUnit unit) ``throws` `InterruptedException { };  ``//尝试获取一个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false``public` `boolean` `tryAcquire(``int` `permits) { }; ``//尝试获取permits个许可，若获取成功，则立即返回true，若获取失败，则立即返回false``public` `boolean` `tryAcquire(``int` `permits, ``long` `timeout, TimeUnit unit) ``throws` `InterruptedException { }; ``//尝试获取permits个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false`
+//尝试获取一个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
+public boolean tryAcquire() { };    
+//尝试获取一个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false
+public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException { }; 
+//尝试获取permits个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
+public boolean tryAcquire(int permits) { }; 
+//尝试获取permits个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false
+public boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws InterruptedException { }; 
 ```
 
 　　另外还可以通过 availablePermits() 方法得到可用的许可数目。
@@ -1208,7 +1275,36 @@ Semaphore 类位于 java.util.concurrent 包下，它提供了2个构造器：
 　　假若一个工厂有 5 台机器，但是有 8 个工人，一台机器同时只能被一个工人使用，只有使用完了，其他工人才能继续使用。那么我们就可以通过 Semaphore 来实现：
 
 ```java
-`public` `class` `Test {``    ``public` `static` `void` `main(String[] args) {``        ``int` `N = ``8``;            ``//工人数``        ``Semaphore semaphore = ``new` `Semaphore(``5``); ``//机器数目``        ``for``(``int` `i=``0``;i<N;i++)``            ``new` `Worker(i,semaphore).start();``    ``}``    ` `    ``static` `class` `Worker ``extends` `Thread{``        ``private` `int` `num;``        ``private` `Semaphore semaphore;``        ``public` `Worker(``int` `num,Semaphore semaphore){``            ``this``.num = num;``            ``this``.semaphore = semaphore;``        ``}``        ` `        ``@Override``        ``public` `void` `run() {``            ``try` `{``                ``semaphore.acquire();``                ``System.out.println(``"工人"``+``this``.num+``"占用一个机器在生产..."``);``                ``Thread.sleep(``2000``);``                ``System.out.println(``"工人"``+``this``.num+``"释放出机器"``);``                ``semaphore.release();           ``            ``} ``catch` `(InterruptedException e) {``                ``e.printStackTrace();``            ``}``        ``}``    ``}``}`
+public class Test {
+    public static void main(String[] args) {
+        int N = 8;            //工人数        
+        Semaphore semaphore = new Semaphore(5); //机器数目       
+        for (int i = 0; i < N; i++) new Worker(i, semaphore).start();
+    }
+
+    static class Worker extends Thread {
+        private int num;
+        private Semaphore semaphore;
+
+        public Worker(int num, Semaphore semaphore) {
+            this.num = num;
+            this.semaphore = semaphore;
+        }
+        
+        @Override
+        public void run() {
+            try {
+                semaphore.acquire();
+                System.out.println("工人" + this.num + "占用一个机器在生产...");
+                Thread.sleep(2000);
+                System.out.println("工人" + this.num + "释放出机器");
+                semaphore.release();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}
 ```
 
 执行结果：
