初探LinkedList线程安全问题（一）

Java中LinkedList是线程不安全的，那么如果在多线程程序中有多个线程访问LinkedList的话会出现什么问题呢？

抛出ConcurrentModificationException

JDK代码里，ListItr的add(), next(), previous(), remove(), set()方法都会跑出ConcurrentModificationException。

final void checkForComodification() {   
        if (modCount != expectedModCount)    
        throw new ConcurrentModificationException();    
    }

代码中，modCount记录了LinkedList结构被修改的次数。Iterator初始化时，expectedModCount=modCount。任何通过Iterator修改LinkedList结构的行为都会同时更新expectedModCount和modCount，使这两个值相等。通过LinkedList对象修改其结构的方法只更新modCount。所以假设有两个线程A和B。A通过Iterator遍历并修改LinkedList，而B，与此同时，通过对象修改其结构，那么Iterator的相关方法就会抛出异常。这是相对容易发现的由线程竞争造成的错误。

通过LinkedList对象修改其结构

如果两个线程都是通过LinkedList对象修改其结构，会发生什么呢？我们先看一下JDK中LinkedList的数据结构。

这是一个双向循环链表。header的作用就是能快速定位链表的头和尾。图中，“n”表示next，“p”表示previous。header的n指向first element；p指向last element。当一个线程A调用LinkedList的addFirst方法时（假设添加节点“4”），它首先更新“4”的n和p，n->3, p->header。此为第一步。第二步，更新节点“3”和herder的n和p，3n不变, 3p->4, headern->4, headerp不变。假设两个线程A，B同时调用addFirst(4), addFirst(5)，会发生什么呢？很可能4，5的n指向3，p都指向header。（这里不是很确定，没有写代码测试，貌似无法从LinkedList获得entry）。也可能addFirst后，紧接着发现getFirst已经不是刚刚加入的元素。

package linkedlist;

import java.util.Iterator;   
import java.util.LinkedList;    
import java.util.concurrent.Executors;

public class Test {

    private final LinkedList<Integer> list = new LinkedList<Integer>();

    public Test() {   
        Thread add1 = new Thread(new Runnable() {

            @Override   
            public void run() {    
                int number = 0;    
                while (true) {    
                    if (number == 10)    
                        number = 0;    
                    // System.out.println("Writing " + number);    
                    list.addFirst(number);    
                    int first = list.getFirst();    
                    if (first != number) {    
                        System.err.println("ERROR!!! " + number + " " + first);    
                        System.exit(-1);    
                    }    
                    number++;    
                    System.out.flush();    
                    try {    
                        Thread.sleep(2);    
                    } catch (InterruptedException e) {    
                        // TODO Auto-generated catch block    
                        e.printStackTrace();    
                    }    
                }    
            }    
        });

        Thread add2 = new Thread(new Runnable() {

            @Override   
            public void run() {    
                int number = 100;    
                while (true) {    
                    if (number > 119) {    
                        number = 100;    
                    }    
                    // System.out.println("Writing " + letter);    
                    // System.out.flush();    
                    list.addFirst(number);    
                    int first = list.getFirst();    
                    if (first != number) {    
                        System.err.println("ERROR!!! " + number + " " + first);    
                        System.exit(-1);    
                    }    
                    number++;    
                    try {    
                        Thread.sleep(2);    
                    } catch (InterruptedException e) {    
                        // TODO Auto-generated catch block    
                        e.printStackTrace();    
                    }    
                }    
            }    
        });

        Executors.newCachedThreadPool().execute(add1);   
        Executors.newCachedThreadPool().execute(add2);    
        // Executors.newCachedThreadPool().execute(read2);    
    }

    /**   
     * @param args    
     */    
    public static void main(String[] args) {    
        Test test = new Test();    
    }    
}

程序输出:

ERROR!!! 0 100

总结一下，线程安全问题是由多个线程同时写或同时读写同一个资源造成的。这里只是通过分析LinkedList的相关源码浅显的分析，下一步就要考虑如何解决或避免线程竞争了。