Updated 'src/Ch15_Networking_and_Threads_Make_a_Connection.md'

Author: gnu4cn

src/Ch15_Networking_and_Threads_Make_a_Connection.md

@@ -234,7 +234,7 @@ Socket chatSocket = new Socket("196.164.1.103", 5000);
     // InputStreamReader 是底层字节流（就比如这里的从套接字获取
     // 到的那个），与高级别字符流（如同后面那个作为链式流顶部的
     // `BufferedReader`）之间的“桥梁”
-    // 
+    //
     // 这里只须从该套接字请求一个输入流即可！所获取到的，就是
     // 一个低级别的连接性流，不过这里只要将其链接到某个对文本
     // 更加友好的东西上（All we have to do is ASK the socket for
@@ -327,8 +327,7 @@ Socket chatSocket = new Socket("196.164.1.103", 5000);
 
 你还等什么呢，若没有这个 app，没人知道你会失去些什么机会。
 
-1） **连接**
-
+1. **连接**
 
     **Connect**
 
@@ -339,8 +338,7 @@ Socket chatSocket = new Socket("196.164.1.103", 5000);
     *图 19 - `AdviceGuy` app 建立连接*
 
 
-2) **读取**
-
+2. **读取**
 
     **Read**
 
@@ -473,11 +471,11 @@ import java.net.*;
 public class DailyAdviceServer {
     // 日常劝解来自这个数组
     // （请记住，这些字符串是由编码编辑器包装起来的单词。绝不要在字符串
-    // 中间敲入回车（remember, these Strings were word-wrapped by 
+    // 中间敲入回车（remember, these Strings were word-wrapped by
     // the code editor. Never hit return in the middle of a String）！）
     String[] adviceList = {
-        "少食多餐", 
-        "买些紧身牛仔裤。他们不会让你看起来显胖。", 
+        "少食多餐",
+        "买些紧身牛仔裤。他们不会让你看起来显胖。",
         "一个字：不合适",
         "就今天而言，要诚实，告诉你的老板你的真实想法。",
         "对于这个发型，你应该三思而后行"
@@ -498,7 +496,7 @@ public class DailyAdviceServer {
                 // 客户端通信的 `Socket`（在某个匿名端口）
                 //
                 // the accept method blocks (just sits there) until
-                // a request comes in, and then the method returns 
+                // a request comes in, and then the method returns
                 // a Socket(on some anonymous port) for communicating
                 // with the client
                 Socket sock = serverSock.accept();
@@ -507,7 +505,7 @@ public class DailyAdviceServer {
                 // PrintWriter，并把一个字符串的劝解消息，发送给他（println()）
                 // 而由于完成了这个客户端的请求，所以随后就要关闭这个套接字。
                 //
-                // now we use the Socket connection to the client to make a 
+                // now we use the Socket connection to the client to make a
                 // PrintWriter and send it (println()) a String advice message
                 // Then we close the Socket because we're done with this client.
                 //
@@ -695,9 +693,9 @@ public class SimpleChatClientA extends JFrame {
         try {
             // 由于用的是 localhost ，因此可以在一台机器上测试客户端
             // 和服务器。
-            // 
-            // 这里就是构造 Socket 与 PrintWriter （这个 setUpNetworking() 
-            // 方法，是在刚刚显示出该 app 的 GUI 界面后，从类 SimpleChatClientA 
+            //
+            // 这里就是构造 Socket 与 PrintWriter （这个 setUpNetworking()
+            // 方法，是在刚刚显示出该 app 的 GUI 界面后，从类 SimpleChatClientA
             // 构造器调用）。
             sock = new Socket("127.0.0.1", 5000);
             writer = new PrintWriter(new OutputStreamWriter(sock.getOutputStream(), "UTF-8"));
@@ -920,7 +918,7 @@ Java 中的多线程技术，意味着这里必须同时要了解 *线程* 及
 // 这里的是否像这样输入代码无关。）
 //
 // The Runnable interface defines only one method,
-// public void run(). (Remember, it's an interface so the 
+// public void run(). (Remember, it's an interface so the
 // method is public regardless of whether you type it in that
 // way.)
 public void run () {
@@ -975,7 +973,7 @@ class ThreadTester {
         // 得到新的执行线程。在启动线程前，线程还不成其为线程。
         // 在启动 Thread 实例之前，他就跟其他的对象一样，
         // 只是个 Tread 的实例，而不会有任何真实的 “线程特征”（
-        // Before that, it's just a Thread instance, like any 
+        // Before that, it's just a Thread instance, like any
         // other object, but it won't have any real 'threadness'）。
         myThread.start();
 
@@ -1196,7 +1194,7 @@ public class MyRunnable implements Runnable {
     }
 
     public void doMore () {
-    
+
         // 在这里调用 sleep() 将强制新线程离开当前运行状态！
         try {
             Thread.sleep(2000);
@@ -1244,7 +1242,7 @@ public class RunThreads implements Runnable {
         // 给这两个线程取名字。
         alpha.setName("Alpha thread");
         beta.setName("Beta thread");
-        
+
         // 启动这两个线程。
         alpha.start();
         beta.start();
@@ -1269,7 +1267,7 @@ public class RunThreads implements Runnable {
 经测试（重复运行 20 遍），上面的代码，运行的结果均为：
 
 ```console
-$ java -jar build/libs/com.xfoss.learningJava-0.0.1.jar 
+$ java -jar build/libs/com.xfoss.learningJava-0.0.1.jar
 Alpha thread is running.
 Alpha thread is running.
 Alpha thread is running.
@@ -1301,7 +1299,7 @@ public class RunThreads implements Runnable {
         // 给这两个线程取名字。
         alpha.setName("Alpha thread");
         beta.setName("Beta thread");
-        
+
         // 启动这两个线程。
         alpha.start();
         beta.start();
@@ -1330,7 +1328,7 @@ public class RunThreads implements Runnable {
 运行结果就变成：
 
 ```console
-$ java -jar build/libs/com.xfoss.learningJava-0.0.1.jar 
+$ java -jar build/libs/com.xfoss.learningJava-0.0.1.jar
 Alpha thread is running.
 Beta thread is running.
 Beta thread is running.
@@ -1344,7 +1342,7 @@ Alpha thread is running.
 ```
 
 ```console
-$ java -jar build/libs/com.xfoss.learningJava-0.0.1.jar 
+$ java -jar build/libs/com.xfoss.learningJava-0.0.1.jar
 Alpha thread is running.
 Beta thread is running.
 Alpha thread is running.
@@ -1358,7 +1356,7 @@ Beta thread is running.
 ```
 
 ```console
-$ java -jar build/libs/com.xfoss.learningJava-0.0.1.jar 
+$ java -jar build/libs/com.xfoss.learningJava-0.0.1.jar
 Alpha thread is running.
 Beta thread is running.
 Beta thread is running.
@@ -1563,7 +1561,7 @@ public class RyanAndMonicaJob implements Runnable {
 
         String currentThread = Thread.currentThread().getName();
 
-        System.out.format("%s 即将进行支取，数额为 %d, 此时余额为 %d\n", 
+        System.out.format("%s 即将进行支取，数额为 %d, 此时余额为 %d\n",
                 currentThread, amount, account.getBalance());
 
         // 检查余额，在余额不足以进行支取时，只打印一条消息。而有
@@ -1580,7 +1578,7 @@ public class RyanAndMonicaJob implements Runnable {
             System.out.format("%s 醒过来了\n", currentThread);
 
             account.withdraw(amount);
-            System.out.format("%s 完成了支取，支出数额 %d, 此时账户余额为 %d\n", 
+            System.out.format("%s 完成了支取，支出数额 %d, 此时账户余额为 %d\n",
                     currentThread, amount, account.getBalance());
         }
         else {
@@ -1595,7 +1593,7 @@ public class RyanAndMonicaJob implements Runnable {
 该程序某次运行的输出为：
 
 ```console
-$java -jar build/libs/com.xfoss.learningJava-0.0.1.jar                         ✔ 
+$java -jar build/libs/com.xfoss.learningJava-0.0.1.jar                         ✔
 Monica 即将进行支取，数额为 80, 此时余额为 100
 Ryan 即将进行支取，数额为 30, 此时余额为 100
 Ryan 即将睡过去
@@ -1690,7 +1688,7 @@ private synchronized void makeWithdrawal (int amount) {
 
     String currentThread = Thread.currentThread().getName();
 
-    System.out.format("---------\n%s 即将进行支取，支取数额为 %d\n", 
+    System.out.format("---------\n%s 即将进行支取，支取数额为 %d\n",
             currentThread, amount, account.getBalance());
 
     if (account.getBalance() >= amount){
@@ -1703,7 +1701,7 @@ private synchronized void makeWithdrawal (int amount) {
         System.out.format("%s 醒过来了\n", currentThread);
 
         account.withdraw(amount);
-        System.out.format("%s 完成了支取，支出数额 %d, 此时账户余额为 %d\n", 
+        System.out.format("%s 完成了支取，支出数额 %d, 此时账户余额为 %d\n",
                 currentThread, amount, account.getBalance());
     }
     else {
@@ -2215,8 +2213,8 @@ public class SimpleChatClient extends JFrame {
         // 了一个新线程。该线程的作业，是从服务器的套接字流进行读取，之后
         // 在滚动文本区显示出全部传入消息。
         //
-        // We're starting a new thread, using a new inner class as the 
-        // Runnable(job) for the thread. The thread's job is to read 
+        // We're starting a new thread, using a new inner class as the
+        // Runnable(job) for the thread. The thread's job is to read
         // from the server's socket stream, displaying any incoming
         // messages in the scrolling text area.
         Thread readerThread = new Thread(new IncomingReader());
@@ -2351,7 +2349,7 @@ public class VerySimpleChatServer {
             } catch (Exception ex) {ex.printStackTrace();}
         }
     }
-    
+
     public void tellEveryOne(String message) {
         Iterator it = clientOutputStreams.iterator();
 
@@ -2386,7 +2384,7 @@ public class VerySimpleChatServer {
 > 事实上，这里就 *应该* 把这些方法同步化，以阻止其他线程以别的方式来访问这些方法。由于这里的示例并没有其他代码会读写到银行账户，因此就没有那样做（Actually, we *should* have synchronized those methods, to prevent other threads from accessing those methods in other ways. We didn't bother, because our example didn't have any other code accessing the account）。
 >
 > 不过需要补充的是，对读取器与设置器（或者说这个示例中的 `checkBalance()` 与 `withdraw()`）的同步化，是不充分的。请记住，同步化的点位，是要令到某个特定代码部分以 **原子方式** 工作。也就是说，同步化不光是所要关注的一些单个方法，而是那些要求 **多个步骤去完成** 的方法！请稍加思考。假如这里没有将 `makeWithdrawl()`方法同步化，Ryan 就会检查完账户余额（通过调用同步化的 `checkBalance()` 方法），然后立即退出该方法并交回那把钥匙（But synchronizing the getters and setters(or in this case the `checkBalance()` and `withdraw()`) isn't enough. Remember, the point of sysnchronization is to make a specific section of code work ATOMICALLY. In other words, it's not just the individual methods we care about, it's methods that requires ***more than one step to complete***! Think about it. If we had not synchronized the `makeWithdrawal()` method, Ryan would have checked the balance(by calling the synchronized `checkBalance()`), and then immediately exited the method and returned the key）！
-> 
+>
 > 当然他就在他醒来后，再度取得那把钥匙，这样他就可以调用那个同步的 `withdraw()`方法，然而这样做仍留下了在同步化之前曾遇到过的同样问题！Ryan能够检查余额、睡过去，然后 Monica 就可以进入并在 Ryan 有机会醒来且完成他的提取之前，对余额进行检查（Of course he would grad the key again, after he wakes up, so that he can call the synchronized `withdraw()` method, but this still leaves us with the same problem we had before synchronization! Ryan can check the balance, go to sleep, and Monica can come in and also check the balance before Ryan has a chance to wakes up and completes his withdrawal）。
 >
 >因此将全部存取方法进行同步化，从而阻止其他线程介入，可能是个不错的主意，但仍需把那些具有必须以一个原子单元方式执行语句的方法，加以同步化（So synchronizing all the access methods is probably a good idea, to prevent other threads from getting in, but you still need to synchronizing the methods that have statements that must execute as one atomic unit）。
@@ -2442,20 +2440,20 @@ public class BeatBoxFinal extends JFrame{
     JLabel tempoLabel = null;
 
     String [] instrumentNames = {
-        "贝斯鼓（低音鼓）", 
+        "贝斯鼓（低音鼓）",
         "闭镲（闭合击镲）",
-        "空心钹（开音踩钹）", 
-        "小鼓（军鼓）", 
-        "双面钹（强音钹）", 
+        "空心钹（开音踩钹）",
+        "小鼓（军鼓）",
+        "双面钹（强音钹）",
         "拍手（拍掌声）",
-        "高音鼓（高音桶鼓）", 
-        "高音圆鼓（高音小鼓）", 
-        "沙锤（沙铃）", 
-        "口哨", 
+        "高音鼓（高音桶鼓）",
+        "高音圆鼓（高音小鼓）",
+        "沙锤（沙铃）",
+        "口哨",
         "低音手鼓",
-        "牛铃（牛颈铃）", 
-        "颤音叉", 
-        "中低音桶鼓", 
+        "牛铃（牛颈铃）",
+        "颤音叉",
+        "中低音桶鼓",
         "高音撞铃",
         "开音高音手鼓"};
 
@@ -2534,7 +2532,7 @@ public class BeatBoxFinal extends JFrame{
         btnDownTempo.addActionListener(new DownTempoListener());
         btnBox.add(btnDownTempo);
 
-        tempoLabel = new JLabel(String.format("速度因子：%.2f", 1.00f)); 
+        tempoLabel = new JLabel(String.format("速度因子：%.2f", 1.00f));
         btnBox.add(tempoLabel);
 
         JButton sendItBtn = new JButton("发出🚀");
@@ -2598,7 +2596,7 @@ public class BeatBoxFinal extends JFrame{
     // 使用那个矢量值，作为在那个清单中显式内容的源。
     //
     // When a message comes in, we read(deserialize) the two objects(the
-    // message and the ArrayList of Boolean checkbox state values) and 
+    // message and the ArrayList of Boolean checkbox state values) and
     // add it to the JList component. Adding to a JList is a two-step
     // thing: you keep a Vector of the lists data(Vector is an old-fashioned
     // ArrayList), and then tell the JList to use that Vector as it's source for