LinkedList源码解读

    LinkedList里每一个元素都被包装成为了一个内部类，这个内部类维护着三个内存地址，所被存放对象的引用地址，上一个节点和下一个节点的引用地址。一个LinkedList对象第一个节点的上一个节点的内存地址为null，最后一个节点的下一个节点的内存地址为null。

 private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

    一个LinkeList对象只需要维护第一个节点的内存地址和最后一个节点的内存地址，就可以把所有所需要维护的实际对象而不被GC回收。除此之外，为了功能，LinkedList对象还维护着链表节点的数量。ps:   transient关键字，序列化的时候不要序列化被该修饰符修饰的变量。

 transient int size = 0;

    /**
     * Pointer to first node.
     * Invariant: (first == null && last == null) ||
     *            (first.prev == null && first.item != null)
     */
    transient Node<E> first;

    /**
     * Pointer to last node.
     * Invariant: (first == null && last == null) ||
     *            (last.next == null && last.item != null)
     */
    transient Node<E> last;

 常用api，没什么好说的了，无非就是增删获取。对比ArrayList，LinkedList的插入和删除速度会比较快，因为LinkedLIst只需要改变上一个节点和下一个节点的引用就可以了，而ArrayList需要移动整个数组。而获取元素ArrayList的效率比LinkedList高。

public E getFirst()
public E getLast()
public E removeFirst()
public E removeLast()
public void addFirst(E e)
public void addLast(E e)
public boolean contains(Object o)
public int size()
public boolean add(E e)
public boolean addAll(Collection<? extends E> c)
public void clear()
public E remove(int index)

使用LinkedList实现消息队列

public class Exec {
    public static void main(String[] args) {
        // 生成同步列队
        SynchronizedQuery synQuery = new SynchronizedQuery();
        // 生成写入线程
        WriteThread writeThread = new WriteThread(synQuery);
        // 生成读取线程
        ReadThread readThread = new ReadThread(synQuery);
        // 启动两个线程
        readThread.start();
        writeThread.start();
    }
}
// 写入线程
class WriteThread extends Thread {
    // 同步队列类变量
    private SynchronizedQuery synQuery;
    // 该构造函数初始化同步队列类变量
    public WriteThread(SynchronizedQuery synQuery) {
        this.synQuery = synQuery;
    }
    // 线程运行主体
    public void run() {
        // 给同步队列添加字符串变量
        synQuery.addElement(new String("欢迎您！"));
    }
}

class ReadThread extends Thread {
    // 同步队列类变量
    private SynchronizedQuery synQuery;
    // 该构造函数初始化同步队列类变量
    public ReadThread(SynchronizedQuery synQuery) {
        this.synQuery = synQuery;
    }
    // 线程运行主体
    public void run() {
        // 读取同步队列中的字符串变量
        System.out.println((String) synQuery.popElement());
    }
}

class SynchronizedQuery {
    // 存储元素的LinkedList
    private LinkedList linkedList = new LinkedList();
    // 添加元素的同步方法
    public synchronized void addElement(Object obj) {
        linkedList.addFirst(obj);
        // 通知其他线程已有元素加入队列
        notify();
    }
    // 取出元素的同步方法
    public synchronized Object popElement() {
        // 如果队列为空，则挂起当前线程，等待其他线程添加元素
        while (linkedList.isEmpty()) {
            try {
                wait();
            } catch (InterruptedException ex) {
            }
        }
        return linkedList.removeLast();
    }
}