读<<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块的简单，不要在里面搞花样，不单单是多线程的东西