看源码，解疑惑

 看JDK源码，解疑惑

 

    从SUN公司主页上搞下来JDK5.0的源码，可以好好研究了。开始吧。

 

    1、Java定时器原理是怎么样的？

    解包jdk_sec-1_5_0-src-jrl，在/j2se/src/share/classes/java/util中找到Timer类。

1. private TaskQueue queue = new TaskQueue();
3. private TimerThread thread = new TimerThread(queue);

    我们找到了一个Timer的任务队列，找到了一个实际运行的线程类。

    再来看看还有什么：

1.     private void mainLoop() {
2.         while (true) {
3.             try {
4.                 TimerTask task;
5.                 boolean taskFired;
6.                 synchronized(queue) {
7.                     // Wait for queue to become non-empty
8.                     while (queue.isEmpty() && newTasksMayBeScheduled)
9.                         queue.wait();
10.                     if (queue.isEmpty())
11.                         break; // Queue is empty and will forever remain; die
13.                     // Queue nonempty; look at first evt and do the right thing
14.                     long currentTime, executionTime;
15.                     task = queue.getMin();
16.                     synchronized(task.lock) {
17.                         if (task.state == TimerTask.CANCELLED) {
18.                             queue.removeMin();
19.                             continue;  // No action required, poll queue again
20.                         }
21.                         currentTime = System.currentTimeMillis();
22.                         executionTime = task.nextExecutionTime;
23.                         if (taskFired = (executionTime<=currentTime)) {
24.                             if (task.period == 0) { // Non-repeating, remove
25.                                 queue.removeMin();
26.                                 task.state = TimerTask.EXECUTED;
27.                             } else { // Repeating task, reschedule
28.                                 queue.rescheduleMin(
29.                                   task.period<0 ? currentTime   - task.period
30.                                                 : executionTime + task.period);
31.                             }
32.                         }
33.                     }
34.                     if (!taskFired) // Task hasn't yet fired; wait
35.                         queue.wait(executionTime - currentTime);
36.                 }
37.                 if (taskFired)  // Task fired; run it, holding no locks
38.                     task.run();
39.             } catch(InterruptedException e) {
40.             }
41.         }
42.     }

    这是最核心的死循环方法，可以看见，在循环中通过不断地获取系统时间，直到特定时间到达。

 

-------------------------------------------------------我是无聊的分割线-------------------------------------------------------------------

 

    2、String类型实际是怎么实现的。

1.     /** The value is used for character storage. */
2.     private final char value[];
4.     /** The offset is the first index of the storage that is used. */
5.     private final int offset;
7.     /** The count is the number of characters in the String. */
8.     private final int count;
10.     /** Cache the hash code for the string */
11.     private int hash; // Default to 0

    看到了一个char类型数组，它才是实现String的根本，还有几个辅助属性。值得注意的是，String内容实际是不可变的，举例：

1.     public String concat(String str) {
2.     int otherLen = str.length();
3.     if (otherLen == 0) {
4.         return this;
5.     }
6.     char buf[] = new char[count + otherLen];
7.     getChars(0, count, buf, 0);
8.     str.getChars(0, otherLen, buf, count);
9.     return new String(0, count + otherLen, buf);
10.     }

    这是其中的一个字符串连接的方法，可以看到String所有的方法，只要是牵涉到对字符串更改的，一律调用构造器生成一个新的返回，而根本不更改本身的内容，不过StringBuffer的内容却是可变的，看源码便知。

 

-------------------------------------------------------我是可爱的分割线-------------------------------------------------------------------

 

    3、关于Thread。

    我们都知道Thread实现了Runnable接口。不过现在我们看看里面的一个有趣的方法：

1.     public static void sleep(long millis, int nanos) 
2.     throws InterruptedException {
3.     if (millis < 0) {
4.             throw new IllegalArgumentException("timeout value is negative");
5.     }
7.     if (nanos < 0 || nanos > 999999) {
8.             throw new IllegalArgumentException(
9.                 "nanosecond timeout value out of range");
10.     }
12.     if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
13.         millis++;
14.     }
16.     sleep(millis);
17.     }

    看到了吧，纳秒——根本就是假的，我们都被JDK骗了。Java常规控制线程的时间精度是非常低的，根本不可能接近纳秒的级别，至于你传入的纳秒参数，下场就是要么变成0，要么变成1毫秒。

 

-------------------------------------------------------我是傻帽的分割线-------------------------------------------------------------------

 

    4、容器类的容量变化的实现：

    以Vector为例吧，找到了一个需要变化容量的方法：

1. //这是它实际存储对象的数组
2. protected Object[] elementData;
4.     private void ensureCapacityHelper(int minCapacity) {
5.     int oldCapacity = elementData.length;
6.     if (minCapacity > oldCapacity) {
7.         Object[] oldData = elementData;
8.         int newCapacity = (capacityIncrement > 0) ?
9.         (oldCapacity + capacityIncrement) : (oldCapacity * 2);
10.             if (newCapacity < minCapacity) {
11.         newCapacity = minCapacity;
12.         }
13.         elementData = new Object[newCapacity];
14.         System.arraycopy(oldData, 0, elementData, 0, elementCount);
15.     }
16.     }

    可以看到它的容器大小增长策略，如果有合理的增量，当然听用户的，否则简单地乘2完事。

 

    这只是随便挑了几个JDK的类看一看而已，相信进一步的研究会有更多收获。