讀<<Java解惑>>後的碎嘴子（第八章）

第八章--庫問題（第二季）

76.

public class PingPong{
public static synchronized void main(String[] a){
    Thread t = new Thread(){
    public void run(){ pong(); }
    t.run();
    System.out.print( "Ping" );
}
static synchronized void pong(){
    System.out.print( "Pong" );
}
}

結果是PongPing而不是PingPong，本章終於進入了多線程的領域，作爲第一條初步探討了類級鎖機制，同時結果又帶有娛樂性質：異步啓動線程應該調用start()方法而不是run()，這個很多人一初學多線程都會用錯
總結：需要了解對象鎖和類級鎖的內部機制，同時要區分主線程和衍生線程的特性

77.本條要完全理解比較有難度，涉及到了java中最複雜的鎖機制，要想理解其意義，書裏給出的篇幅並不夠用，儘管已經敘述了足夠複雜了
總結：多線程鎖方面，可以參考CoreJava卷一的最後一章

78.

Set<String> s = new HashSet<String>();
s.add("foo");
Iterator it = s.iterator();
Method m = it.getClass().getMethod("hasNext");
System.out.println(m.invoke(it));

運行時會得到java.lang.IllegalAccessException的異常，本章從上條開始以來逐漸變得難以理解了，要注意Object.getClass()方法返回的是具體實現類的Class對象，這個具體類不一定可以從外面直接訪問
總結：本條的問題在現實中很少碰到，和大多數經典書籍提及的那樣，慎用反射，除非你明確地瞭解其中的細節

79.

public class Pet{
    public final String name;
    public final String food;
    public final String sound;
    public Pet(String name, String food, String sound){
        this.name = name;
        this.food = food;
        this.sound = sound;
    }
    public void eat(){
        System.out.println(name + ": Mmmmm, " + food );
    }
    public void play(){
        System.out.println(name + ": " + sound + " " + sound);
    }
    public void sleep(){
        System.out.println(name + ": Zzzzzzz...");
    }
    public void live(){
        new Thread(){
            public void run(){
                while(true){
                    eat();
                    play();
                    sleep();
                }
            }
        }.start();
    }
    public static void main(String[] args){
        new Pet("Fido", "beef", "Woof").live();
    }
}

結果是編譯不通過，編譯器找不到sleep()方法，原因很簡單，發生了上一章提及的shade（在這裏表現爲塊中的sleep()方法鏈接到了Thread.sleep(long l)，shade了Pet類中的sleep()方法）
總結：這種編譯時的錯誤在這個時代還是很容易被發現的，大師也再三強調了（CoreJava也有提到），多線程儘量以實現Runnable而不是繼承Thread的方式來達成

80.

public class Test {

	public static void main(String... args) throws Exception {
		new Test().greetWorld();
	}

	private void greetWorld() throws Exception {
		System.out.println(Inner.class.newInstance());
	}

	public class Inner {
		public String toString() {
			return "Hello world";
		}
	}
}

結果是運行時newInstance()方法發生異常，這條很好的描述了普通內部類和靜態內部類的區別所在：是否擁有一個外部類的引用，這裏的問題在於通過反射獲取一個普通內部類的對象，編譯器是不會爲你做手腳的，你需要手動爲構造方法提供一個顯式的外部類對象引用
總結：儘管不太可能用反射來實例化內部類，事實上重點在於瞭解內部類被構造時，內部到底發生了什麼

81.

String greeting = "Hello World";
for(int i = 0; i < greeting.length(); i++)
    System.out.write(greeting.charAt(i));

結果是什麼也不會輸出，例子很簡單，頭一次看到了PrintStream.write(int i)方法，這條實際意義不大，但是敘述了一些流緩衝的細節值得了解

82.

public class Test {

	static final String COMMAND = "java BeerBlast slave";
	
	public static void main(String... args) throws Exception{
		Process process = Runtime.getRuntime().exec(COMMAND);
		int exitValue = process.waitFor();
		System.out.println("exit value = " + exitValue);
	}

}

結果是會持續執行不停止，涉及到了很多應用都會用到的Runtime類和Process類，本條只敘述了很少的一部分
總結：需要通過javadocAPI文檔來了解該部分的詳細內容

83.本條過於學術，介紹了因爲序列化而使得實現一個完全的Singleton模式失敗

84.

Thread.currentThread().interrupt();
if(Thread.interrupted()) {
    System.out.println("Interrupted: " +
    Thread.interrupted());
} else{
    System.out.println("Not interrupted: " +
    Thread.interrupted());
}

乍一看結果相當奇怪，會打印Interrupted: false，仔細觀察就會得知，Thread.interrupted()在調用時，會改變當前線程的狀態，具體地說應該是if調用會雖然返回true，但是隨後將中斷狀態變成false
總結：要區別Thread.interrupted()和Thread.isInterrupted()方法，後者纔是測試線程中斷狀態的方法，在這一點前者API的名稱是明顯誤導人的

85.

public class Lazy {
    private static boolean initialized = false;
    private static Thread t = new Thread(new Runnable() {
        public void run() {
            initialized = true;
        }
    });
    static {
        t.start();
    }
    public static void main(String[] args){
        try{
            t.join();
        }catch (InterruptedException e){
            throw new AssertionError(e);
        }
       System.out.println(initialized);
    }
}

到了本章的最後一條了，結果是持續執行不停止，整個過程非常複雜，簡單一句就是主線程和衍生線程因爲都在等待initalized域的初始化而發生了死鎖
總結：保持static塊的簡單，不要在裏面搞花樣，不單單是多線程的東西