1.     List<String> list = new ArrayList<String>();  
2.     for (int i = 0; i < 10; i++) {  
3.         String str = "td" + i;  
4.         list.add(str);  
5.     }  
6.   
7.     for (Iterator it = list.iterator(); it.hasNext();) {  
8.         String str = (String) it.next();  
9.         if (str.equals("td5")) {  
10.             // list.remove(str);  // 删除方法一 
    
11.             it.remove();  // 删除方法二 
    
12.         }  
13.     }  
14. } 
    

1. public boolean remove(Object o) {  
2.     if (o == null) {  
3.         for (int index = 0; index < size; index++)  
4.             if (elementData[index] == null) {  
5.                 fastRemove(index);  
6.                 return true;  
7.             }  
8.     } else {  
9.         for (int index = 0; index < size; index++)  
10.             if (o.equals(elementData[index])) {  
11.                 fastRemove(index);  
12.                 return true;  
13.             }  
14.     }  
15.     return false;  
16. }  
17.   
18. private void fastRemove(int index) {  
19.     modCount++; // 特别注意这里，这里只增加了modCount的值  
20.     int numMoved = size - index - 1;  
21.     if (numMoved > 0)  
22.         System.arraycopy(elementData, index + 1, elementData, index,  
23.                 numMoved);  
24.     elementData[--size] = null; // Let gc do its work  
25. } 
    

1. public E next() {  
2.     checkForComodification();  
3.     try {  
4.         E next = get(cursor);  
5.         lastRet = cursor++;  
6.         return next;  
7.     } catch (IndexOutOfBoundsException e) {  
8.         checkForComodification();  
9.         throw new NoSuchElementException();  
10.     }  
11. }  
12.   
13. final void checkForComodification() {  //注意这个方法
    
14.     if (modCount != expectedModCount)  //检查这两个值是否相同
15.         throw new ConcurrentModificationException();  
16. } 
    

1. public void remove() {  
2.     if (lastRet == -1)  
3.         throw new IllegalStateException();  
4.     checkForComodification();  
5.     try {  
6.         AbstractList.this.remove(lastRet);  
7.         if (lastRet < cursor)  
8.             cursor--;  
9.         lastRet = -1;  
10.         expectedModCount = modCount; // 设置expectedModCount  
11.     } catch (IndexOutOfBoundsException e) {  
12.         throw new ConcurrentModificationException();  
13.     }  
14. }  
15.   
16. final void checkForComodification() {  
17.     if (modCount != expectedModCount)  
18.         throw new ConcurrentModificationException();  
19. } 
    

volatile关键字有什么用？
恐怕比较一下volatile和synchronized的不同是最容易解释清楚的。volatile是变量修饰符，而synchronized则作用于一段代码或方法；看如下三句get代码：

　　geti1()得到存储在当前线程中i1的数值。多个线程有多个i1变量拷贝，而且这些i1之间可以互不相同。换句话说，另一个线程可能已经改 变了它线程内的i1值，而这个值可以和当前线程中的i1值不相同。事实上，Java有个思想叫“主”内存区域，这里存放了变量目前的“准确值”。每个线程 可以有它自己的变量拷贝，而这个变量拷贝值可以和“主”内存区域里存放的不同。因此实际上存在一种可能：“主”内存区域里的i1值是1，线程1里的i1值 是2，线程2里的i1值是3——这在线程1和线程2都改变了它们各自的i1值，而且这个改变还没来得及传递给“主”内存区域或其他线程时就会发生。
而geti2()得到的是“主”内存区域的i2数值。用volatile修饰后的变量不允许有不同于“主”内存区域的变量拷贝。换句话说，一个变量经 volatile修饰后在所有线程中必须是同步的；任何线程中改变了它的值，所有其他线程立即获取到了相同的值。理所当然的，volatile修饰的变量 存取时比一般变量消耗的资源要多一点，因为线程有它自己的变量拷贝更为高效。
既然volatile关键字已经实现了线程间数据同步，又要synchronized干什么呢？呵呵，它们之间有两点不同。首 先，synchronized获得并释放监视器——如果两个线程使用了同一个对象锁，监视器能强制保证代码块同时只被一个线程所执行——这是众所周知的事 实。但是，synchronized也同步内存：事实上，synchronized在“主”内存区域同步整个线程的内存。因此，执行geti3()方法做 了如下几步：
1. 线程请求获得监视this对象的对象锁（假设未被锁，否则线程等待直到锁释放）
2. 线程内存的数据被消除，从“主”内存区域中读入（Java虚拟机能优化此步。。。[后面的不知道怎么表达,汗]）
3. 代码块被执行
4. 对于变量的任何改变现在可以安全地写到“主”内存区域中（不过geti3()方法不会改变变量值）
5. 线程释放监视this对象的对象锁
因此volatile只是在线程内存和“主”内存间同步某个变量的值，而synchronized通过锁定和解锁某个监视器同步所有变量的值。显然synchronized要比volatile消耗更多资源。

附英文原文：
What does volatile do?

This is probably best explained by comparing the effects that volatile and synchronized have on a method. volatile is a field modifier, while synchronized modifies code blocks and methods. So we can specify three variations of a simple accessor using those two keywords:

geti1() accesses the value currently stored in i1 in the current thread. Threads can have local copies of variables, and the data does not have to be the same as the data held in other threads. In particular, another thread may have updated i1 in it’s thread, but the value in the current thread could be different from that updated value. In fact Java has the idea of a “main” memory, and this is the memory that holds the current “correct” value for variables. Threads can have their own copy of data for variables, and the thread copy can be different from the “main” memory. So in fact, it is possible for the “main” memory to have a value of 1 for i1, for thread1 to have a value of 2 for i1 and for thread2 to have a value of 3 for i1 if thread1 and thread2 have both updated i1 but those updated value has not yet been propagated to “main” memory or other threads.

On the other hand, geti2() effectively accesses the value of i2 from “main” memory. A volatile variable is not allowed to have a local copy of a variable that is different from the value currently held in “main” memory. Effectively, a variable declared volatile must have it’s data synchronized across all threads, so that whenever you access or update the variable in any thread, all other threads immediately see the same value. Of course, it is likely that volatile variables have a higher access and update overhead than “plain” variables, since the reason threads can have their own copy of data is for better efficiency.

Well if volatile already synchronizes data across threads, what is synchronized for? Well there are two differences. Firstly synchronized obtains and releases locks on monitors which can force only one thread at a time to execute a code block, if both threads use the same monitor (effectively the same object lock). That’s the fairly well known aspect to synchronized. But synchronized also synchronizes memory. In fact synchronized synchronizes the whole of thread memory with “main” memory. So executing geti3() does the following:

1. The thread acquires the lock on the monitor for object this (assuming the monitor is unlocked, otherwise the thread waits until the monitor is unlocked).
2. The thread memory flushes all its variables, i.e. it has all of its variables effectively read from “main” memory (JVMs can use dirty sets to optimize this so that only “dirty” variables are flushed, but conceptually this is the same. See section 17.9 of the Java language specification).
3. The code block is executed (in this case setting the return value to the current value of i3, which may have just been reset from “main” memory).
4. (Any changes to variables would normally now be written out to “main” memory, but for geti3() we have no changes.)
5. The thread releases the lock on the monitor for object this.

So where volatile only synchronizes the value of one variable between thread memory and “main” memory, synchronized synchronizes the value of all variables between thread memory and “main” memory, and locks and releases a monitor to boot. Clearly synchronized is likely to have more overhead than volatile.

摘自：http://bianbian.org/technology/java/88.html

另一个著名的例子就是Netscape Navigator 早期版本中的取决于时间的随机数字生成器，它泄露了动态生成的用于加密运用SSL的会话中数据的密钥。
About Random encrypted 加密的随机数
随机数生成是许多加密操作不可分割的组成部分。例如，加密密钥需要尽可能地随机，以便使它们很难被复制。加密随机数生成器必须生成在计算上无法进行推算（低于 p < .05 的概率）的输出；即，任何推算下一个输出位的方法不得具有比随机猜测更高的成功几率。
为了说明一连串的随机数字是加密安全的，必须使得用户不可能通过计算重新生成同样序列的随机数。遗憾的是，运用伪随机数字，可以很容易地重新生成同样的序列。用户需要知道的知识就是伪随机数生成器算法和种子值。
    通过加密保护数据基于加密算法和更为随机的种子值就是本文要提出的方法,一个带加密功能的随机数产生器，可以应用于需要加密随机数的场合.为了构成种子值，需要用不同的值组合成一个系统范围内的种子值。这些值包括调用的应用程序可以提供的位，例如鼠标或键盘动作之间的用户反应时间、象进程ID和线程ID这样的系统和用户数据、系统时钟、系统计数器、自由磁盘集群属和散列的用户环境块。接着使用SHA-1散列这个值，输出用于创建一个随机数据流（用于更新系统种子值）。这可以起作用，是因为散列值生成了看似随机的数据，只改变源文档（种子值）中的一个位，任何两个输出的散列共享它们50%的位，尽管两个输出只有一位之差。当然，从理论上讲，有些过程还是周期性的。例如磁盘搜索时间看似随机的，实际取决于易于确定的因素，可以被推测出来。为了获取更好的随机数生成，可以采用硬件生成器，例如Intel的随机数生成器。
   
说明：
    创建加密安全的随机数需要更多的时间，这意味着如果需要快速地在一个短时间内生成大量随机数（例如百万级的数据）是不适合的。在一个简单测试中，用本文提到的RNG生成一百万个随机数的时间花费差不多是伪随机数生成器所用时间的八倍之多。

相关资源：http://www.xfocus.net/articles/200209/451.html

第一步：

windows－>preferences->java->Editor->Code   Assist   中

将auto－activetion中的Enable auto-activetion选项要勾选上

这里面有个时间的设定是为提示代码设定的显示时间。你可以根据自己的情况设定。

第二步：

另注：也可以直接恢复成默认设置。

	Exception Stack Trace:



java.net.SocketTimeoutException: Accept timed out



at java.net.PlainSocketImpl.socketAccept(Native Method)



at java.net.PlainSocketImpl.accept(PlainSocketImpl.java:353)



at java.net.ServerSocket.implAccept(ServerSocket.java:448)



at java.net.ServerSocket.accept(ServerSocket.java:419)



查看build.xml文件无异常，让我好是奇怪，明明昨天还是正常的呀。



后来查看一下Ant Home,发现只有四项，觉得有点不对劲，他细一看，居然指到了/home/fingki/eclipse/plugins/Axis2_service_Archiver_1.3.0/lib下，



重新指定一下Ant Home,运行ant，运行了。



后来研究才发现，原来之前刚装了Axis2的plugins,Axis2_service_Archiver_1.3.0，这样Eclipse重启后优先把Ant Home指向那了，导致ant不工作了。



看来Axis2_service_Archiver_1.3.0这个plugins还是有些bug呀。



具体设置Ant Home如下：在Eclipse中－＞window－＞preferences－＞Ant－＞Runtime－＞Classpath，点击Ant home按钮，重新让其指向eclipse中的ant的plugins文件夹处，



一般都在%Eclipse_home%/plugins/org.apache.ant_1.x.x。