更多库之谜总结

1.在使用多线程时要注意run方法和start方法的区别

t.run();main线程调用t的run方法，并没有创建新线程。

t.start();创建一个新的线程t，并执行。

public class PuzzleDemo76{ public static synchronized void main(String args[]){ //主线程获得PuzzleDemo76对象的锁 Thread t = new Thread(){ public void run(){ pong(); } }; t.start(); System.out.println("ping"); } static synchronized void pong(){ //等待main线程执行完毕，才能够使得t线程获得锁 System.out.println("pong"); } }

2.Thread的join()方法注意点

表示正在被链接的Thread实例调用wait方法，因此会释放锁。

因此如果你需要某个对象的锁的完全控制，则必须确保没有其他线程访问。

import java.util.*; public class PuzzleDemo77{ public static void main(String args[])throws Exception{ final Worker w = new Worker(); Thread t = new Thread(w); t.start(); Timer timer = new Timer(true); timer.schedule(new TimerTask(){ public void run(){ w.keepWorking(); } },500); Thread.sleep(400); w.quit(); //获得w的锁，并执行方法 } } class Worker implements Runnable{ private volatile boolean quitTime = false; public void run(){ while(!quitTime){ pretendToWork(); } System.out.println("Beer is good"); } private void pretendToWork(){ try{ Thread.sleep(300); } catch(Exception e){ } } synchronized void quit() throws Exception{ quitTime = true; Thread.yield();//释放锁 } synchronized void keepWorking(){ quitTime = true; } }

3.HashSet的问题

HashSet<String>s = new HashSet<String>();

Iterator i = s.iterator();这里的i是HashMap.keyIterator类型的。但是因为这个类型是不同包中且非公共的，因此不能调用他的方法。

class HashSet{ private transient HashMap<E,Object> map; public Iterator<E> iterator() { return map.keySet().iterator(); } }

import java.util.*; import java.lang.reflect.*; public class PuzzleDemo78{ public static void main(String args[])throws Exception{ Set<String> s = new HashSet<String>(); s.add("foo"); Iterator iter = s.iterator(); Method m = Iterator.class.getMethod("hasNext"); System.out.println(m.invoke(iter)); } }

4.编译器寻找调用方法的规则：在正确的名称方法的最内层作用域查找需要调用的方法。

5.Class.newInstance和内部类

Class.newInstance()是调用一个空的构造器。

而非静态内部类调用空构造器时，会有一个隐藏的一个参数即外部类实例，因此外表看起来是空的内部类构造器并不是空构造器。

结论：避免使用反射实例化内部类。

import java.lang.reflect.*; public class PuzzleDemo80{ public static void main(String args[])throws Exception{ new PuzzleDemo80().greetWorld(); } private void greetWorld()throws Exception{ Constructor c = Inner.class.getConstructor(PuzzleDemo80.class); System.out.println(c.newInstance(PuzzleDemo80.this)); } public class Inner{ public Inner(){} public String toString(){ return "Hellow"; } } }

6.System.out的一个瑕疵

System.out是一个PrintStream，因此带有缓冲区，但是可以自动刷新。

但是有一个方法例外！

write(int)是唯一一个在自动刷新功能开启的情况下不刷新PrintStream输出流的方法。

public class PuzzleDemo81{ public static void main(String args[]){ String greeting = "Hello "; for(int i=0;i<greeting.length();i++){ System.out.println(greeting.charAt(i)); } } }

7.复制对象的简单方法及解决

实现了io.serializable的类可以简单的通过writeObject和readObject复制对象，并生成一个新的对象。

如果一个类是Singleton，因此只能有一个对象，怎么能够解决这个问题使得通过writeObject和readObject后的对象还是其本身呢？

private Object readResolve(){

return **;

}

import java.io.*; class Dog extends Exception{ public static final Dog INSTANCE = new Dog(); private Dog(){} public String toString(){ return "woof"; } private Object readResolve(){ //实现readResolve方法，使得只有一个实例 return INSTANCE; } } public class PuzzleDemo83{ public static void main(String args[])throws Exception{ Dog dog = Dog.INSTANCE; ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("1.txt")); out.writeObject(dog); out.close(); ObjectInputStream in = new ObjectInputStream(new FileInputStream("1.txt")); Dog dog2 = (Dog)in.readObject(); in.close(); System.out.println(dog==dog2); } }

8.Thread.interrupted()和Thread.isInterrupted()的 区别

Thread.interrupted()方法后会清除当前线程的中断状态。

Thread.isInterrupted()则只是测试是否已经被中断。

public class PuzzleDemo84{ public static void main(String args[]){ Thread.currentThread().interrupt(); if(Thread.currentThread().isInterrupted ()){ System.out.println ("Interrupt:"+Thread.currentThread().isInterrupted()); } else{ System.out.println(" Not Interrupt:"+Thread.currentThread().isInterrupted()); } } }

9.多线程下的初始化

当一个线程访问一个类的某个成员之前，都会去检查这个类是否已经被初始化。

多线程下类初始化有4种情况：

(1)这个类没被初始化。

(2)这个类被当前线程初始化。

(3)这个类被其他线程初始化。

(4)这个类已经被初始化。

当第三种情况下，如果B线程要访问A类的某个成员，则发现正在被C线程初始化，则会等待C线程初始化完毕，才会继续运行。

结论：要明确初始化顺序。

public class PuzzleDemo85{ private static boolean initialize = true; //1 private static Thread t = new Thread(new Runnable(){ //2 public void run(){ initialize = true; } }); static{ System.out.println(initialize); t.start(); //3 } public static void main(String args[]){ try{ System.out.println("main:"+initialize); t.join(); //4 } catch(Exception e){} System.out.println(initialize); //5 } }