LinkedList源码解析二

双向链表的优势：遍历效果优于单向链表。

每个节点类似如下结构：

 定一个静态内部类Node来表示该结构：

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

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

实现LinkedList的get方法

    @Override
    public E get(int index) {
        checkElementIndex(index);
        return node(index).element;
    }
    

 看下index是靠近头还是靠近尾，如果靠近头从头开始找，如果靠近尾就从尾开始找

 拿index和size的一半进行比较

    private Node<E> node(int index) {
        //看下index是靠近头还是靠近尾，如果靠近头从头开始找，如果靠近尾就从尾开始找
        //大于一半，靠近尾
        if (index > (size >> 1)) {
            Node x = last;
            for (int i = size - 1; i > index; i--) {
                x = x.prev;
            }
            return x;
        } else {
            Node x = first;
            for (int i = 0; i < index; i++) {
                x = x.next;
            }
            return x;
        }
    }

实现LinkedList的clear方法 

    @Override
    public void clear() {
        size = 0;
        first = null;
        last = null;
    }

实现LinkedList的add方法 

  @Override
    public void add(int index, E element) {
        checkPositionIndex(index);
        if (index == size) {
            //需要维护Last变量的方法
            linkLast(element);
        } else {
            //需要维护first的方法
            linkBefore(element, node(index));
        }

        size++;
    }

 private void linkBefore(E element, Node<E> node) {
        //1、获取指定的节点 2、获取前一个节点 3、创建新的节点 4、改变指向关系
        Node<E> pre = node.prev;
        Node<E> newNode = new Node<E>(pre, node, element);
        node.prev = newNode;
        if (pre == null) {
            //add(0,element)
            first = newNode;
        } else {
            pre.next = newNode;
        }
    }

    private void linkLast(E element) {
        //拿到last节点
        Node<E> l = last;
        //构建node节点，包含指向关系
        Node<E> newNode = new Node<E>(l, null, element);
        //将链表的last进行修改
        last = newNode;
        if (l == null) {
            //没有元素的情况
            first = newNode;
        } else {
            l.next = newNode;
        }
    }

 实现LinkedList的remove方法 

   @Override
    public E remove(int index) {
        checkElementIndex(index);
        Node<E> node = node(index);
        //index的前一个节点
        Node<E> pre = node.prev;
        //index的后一个节点
        Node<E> next = node.next;
        //改变前一个节点的next，后一个节点的pre

        if (pre == null) {
            //第一个节点
            first = next;
        } else {
            pre.next = next;
            node.prev = null;
        }

        if (next == null) {
            //最后一个节点
            last = pre;
        } else {
            next.prev = pre;
            node.next = null;
        }
        size--;
        return node.element;
    }

 LinkedList里面存着的线程安全问题

public class MainActivity14 extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main14);
        final MyLinkedList2 linkedList = new MyLinkedList2<Integer>();
        for (int i = 0; i < 4; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    linkedList.add(UUID.randomUUID().toString().substring(0, 10));
                    System.out.println(linkedList);
                }
            }).start();
        }

    }
}

 怎么去解决线程安全问题？