arraylist 线程安全（ArrayList）

本文目录

• ArrayList
• arraylist和linkedlist的区别
• 如何创建线程安全的list
• arraylist线程安全吗
• ArrayList和LinkedList都是线程安全的吗
• 如何使ArrayList 线程安全
• arraylist是线程安全的吗
• arraylist为什么线程不安全

ArrayList

Q：ArrayList底层实现是什么？ A：底层实现是数组，ArrayList内部定义了一个数组来存储对象 Q：ArrayList默认的容量是多少？new ArrayList《》()时，指定容量与不指定容量有什么区别？ A：默认容量是10。调用默认构造函数时，只是把一个size为0的空数组赋值给elementData，当第一次添加元素时，数组会扩容到DEFAULT_CAPACITY（10） 指定容量初始化ArrayList时，会创建一个大小为initialCapacity的数组赋值给elementData，在添加第一个元素时，如果initialCapacity小于DEFAULT_CAPACITY，数组将会扩容到DEFAULT_CAPACITY Q：ArrayList的扩容机制是什么？什么时候会进行扩容？ A：分两种情况 Q：1.7与1.8版本的区别 A：1.7版本在初始化时就创建一个容量为10的数组；1.8版本在初始化时创建一个空数组，当第一次add元素时才扩容到10 Q：ArrayList线程安全吗？ A：不安全，如果需要线程安全，则使用Vector，CopyOrWriteArrayList，Collections.synchronizedList() Q：ArrayList在增删时的效率如何？ A：看情况，尾插时，如果不扩容，效率高； 非尾插或者尾插需要扩容时，效率会变低，因为这两种情况都会涉及到数组的拷贝 Q：ArrayList与LinkedList区别 A：基本等同于数组与链接的区别，数组是固定大小，需要一片连续的内存空间，查找快，增删慢；链接不需要连续内存空间，在逻辑上是连续的，查找慢，增删快。二都都是线程不安全的。 遍历性能ArrayList比LinkedList好，因为CPU内部的缓存结构会缓存连续的内存片断，可大幅降低读取内存的性能消耗。 Q：ArrayList适合做队列吗？ A：不适合。队列是FIFO，先进先出，使用数组做队列，需要头插尾出或者头出尾插，这都会涉及到数组的复制，很耗性能。 Q：ArrayList初始化时是否需要指定初始容量 A：容量小于10不需要，大于10时指定容量较好。

arraylist和linkedlist的区别

arraylist和linkedlist的区别：

一、查找元素方法不同：

1、arraylist可以直接通过数组下标找到元素。

2、linkedlist要通过移动指针遍历每个元素，直到找到需要的元素为止。arraylist查找元素的速度比linkedlist快。

二、空间消耗。

1、arraylist的空间浪费主要体现在在list结尾预留了一定的容量空间。

2、而linkedlist的空间浪费则体现在它的每一个元素都要消耗一定的空间。

三、原理不同。

1、arraylist是基于动态数组实现的非线程安全集合。

2、linkedlist是基于链表实现的非线程安全集合。

四、删除元素。

1、arraylist在新增和删除元素时，可能扩容和复制数组。

2、而linkedlist实例化对象只需要修改指针即可。

如何创建线程安全的list

一：使用synchronized关键字

二：使用Collections.synchronizedList()

一、 ArrayList概述：  

ArrayList是基于数组实现的，是一个动态数组，其容量能自动增长，类似于C语言中的动态申请内存，动态增长内存。

ArrayList不是线程安全的，只能用在单线程环境下，多线程环境下可以考虑用Collections.synchronizedList(List l)函数返回一个线程安全的ArrayList类，也可以使用concurrent并发包下的CopyOnWriteArrayList类。

   ArrayList实现了Serializable接口，因此它支持序列化，能够通过序列化传输，实现了RandomAccess接口，支持快速随机访问，实际上就是通过下标序号进行快速访问，实现了Cloneable接口，能被克隆。

 每个ArrayList实例都有一个容量，该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向ArrayList中不断添加元素，其容量也自动增长。自动增长会带来数据向新数组的重新拷贝，因此，如果可预知数据量的多少，可在构造ArrayList时指定其容量。

在添加大量元素前，应用程序也可以使用ensureCapacity操作来增加ArrayList实例的容量，这可以减少递增式再分配的数量。 

注意，此实现不是同步的。如果多个线程同时访问一个ArrayList实例，而其中至少一个线程从结构上修改了列表，那么它必须保持外部同步。

arraylist线程安全吗

如果代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。线程（英文：thread），台湾地区译为执行绪（英文：threadofexecution）、绪程，操作系统技术中的术语，是操作系统能够进行运算调度的最小单位，它被包涵在进程之中，是行程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并行多个线程，每条线程并行执行不同的任务。在UnixSystemV及SunOS中也被称为轻量进程（lightweightprocesses），但轻量进程更多指内核线程(kernelthread)，而把用户线程(userthread)称为线程。计算机科学术语，指运行中的程序的调度单位。***隐藏网址***

ArrayList和LinkedList都是线程安全的吗

都是线程安全的。

ArrayList和LinkedList的区别及其优缺点

ArrayList和LinkedList的大致区别： 

1. ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。

2. 对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。

3. 对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。 

一、同步性 

ArrayList,LinkedList是不同步的，而Vestor是同步的。所以如果不要求线程安全的话，可以使用ArrayList或LinkedList，可以节省为同步而耗费的开销。但在多线程的情况下，有时候就不得不使用Vector了。当然，也可以通过一些办法包装ArrayList,LinkedList，使他们也达到同步，但效率可能会有所降低。 

二、数据增长 

从内部实现机制来讲ArrayList和Vector都是使用Objec的数组形式来存储的。当你向这两种类型中增加元素的时候，如果元素的数目超出了内部数组目前的长度它们都需要扩展内部数组的长度，Vector缺省情况下自动增长原来一倍的数组长度，ArrayList是原来的50%,所以最后你获得的这个集合所占的空间总是比你实际需要的要大。所以如果你要在集合中保存大量的数据那么使用Vector有一些优势，因为你可以通过设置集合的初始化大小来避免不必要的资源开销。 

三、检索、插入、删除对象的效率 

ArrayList和Vector中，从指定的位置（用index）检索一个对象，或在集合的末尾插入、删除一个对象的时间是一样的，可表示为O(1)。但是，如果在集合的其他位置增加或移除元素那么花费的时间会呈线形增长：O(n-i)，其中n代表集合中元素的个数，i代表元素增加或移除元素的索引位置。为什么会这样呢？以为在进行上述操作的时候集合中第i和第i个元素之后的所有元素都要执行(n-i)个对象的位移操作。 

LinkedList中，在插入、删除集合中任何位置的元素所花费的时间都是一样的—O(1)，但它在索引一个元素的时候比较慢，为O(i),其中i是索引的位置。

如何使ArrayList 线程安全

一、

1、使用synchronized关键字；

2.使用Collections.synchronizedList();使用方法如下：

假如你创建的代码如下：List《Map《String,Object》》 data=new ArrayList《Map《String,Object》》();

那么为了解决这个线程安全问题你可以这么使用Collections.synchronizedList()，如：

List《Map《String,Object》》 data=Collections.synchronizedList(new ArrayList《Map《String,Object》》());

其他的都没变，使用的方法也几乎与ArrayList一样，大家可以参考下api文档；

额外说下 ArrayList与LinkedList；这两个都是接口List下的一个实现，用法都一样，但用的场所的有点不同，ArrayList适合于进行大量的随机访问的情况下使用，LinkedList适合在表中进行插入、删除时使用，二者都是非线程安全，解决方法同上（为了避免线程安全，以上采取的方法，特别是第二种，其实是非常损耗性能的）。

二、

定义一个类　MyLinkedList extends LinkedList 

实现同步LinkedList.addFirst(); 和 removeLast();方法！ 

MyLinkedList list = new MyLinkedList (); 

List listProxy = Collections.synchronizedList(list); 

用普通方法时用　listprocxy 的方法，　或者MyLinkedList 全部实现同步。

arraylist是线程安全的吗

如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。比如一个ArrayList类，在添加一个元素的时候，它可能会有两步来完成：1.在Items的位置存放此元素；2.增大Size的值。在单线程运行的情况下，如果Size=0，添加一个元素后，此元素在位置0，而且Size=1；而如果是在多线程情况下，比如有两个线程，线程A先将元素存放在位置0。但是此时CPU调度线程A暂停，线程B得到运行的机会。线程B也向此ArrayList添加元素，因为此时Size仍然等于0（注意哦，我们假设的是添加一个元素是要两个步骤哦，而线程A仅仅完成了步骤1），所以线程B也将元素存放在位置0。然后线程A和线程B都继续运行，都增加Size的值。那好，现在我们来看看ArrayList的情况，元素实际上只有一个，存放在位置0，而Size却等于2。这就是“线程不安全”了，呵呵。上面是找别人的，我也来补充一下：vector线程安全ArrayList非线程安全，但却解约系统性能

arraylist为什么线程不安全

首先说一下什么是线程不安全：线程安全就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问直到该线程读取完，其他线程才可使用。不会出现数据不一致或者数据污染。线程不安全就是不提供数据访问保护，有可能出现多个线程先后更改数据造成所得到的数据是脏数据。 如图，List接口下面有两个实现，一个是ArrayList，另外一个是vector。 从源码的角度来看，因为Vector的方法前加了，synchronized 关键字，也就是同步的意思，sun公司希望Vector是线程安全的，而希望arraylist是高效的，缺点就是另外的优点。 说下原理（百度的，很好理解）： 一个 ArrayList ，在添加一个元素的时候，它可能会有两步来完成：1. 在 Items 的位置存放此元素；2. 增大 Size 的值。在单线程运行的情况下，如果 Size = 0，添加一个元素后，此元素在位置 0，而且 Size=1；而如果是在多线程情况下，比如有两个线程，线程 A 先将元素存放在位置 0。但是此时 CPU 调度线程A暂停，线程 B 得到运行的机会。线程B也向此 ArrayList 添加元素，因为此时 Size 仍然等于 0 （注意哦，我们假设的是添加一个元素是要两个步骤哦，而线程A仅仅完成了步骤1），所以线程B也将元素存放在位置0。然后线程A和线程B都继续运行，都增加 Size 的值。那好，现在我们来看看 ArrayList 的情况，元素实际上只有一个，存放在位置 0，而 Size 却等于 2。这就是“线程不安全”了。示例程序：package test;import java.util.ArrayList;import java.util.List;public class ArrayListInThread implements Runnable {List《String》 list1 = new ArrayList《String》();// not thread safe// List《String》 list1 = Collections.synchronizedList(new ArrayList《String》());// thread safepublic void run() {try {Thread.sleep((int)(Math.random() * 2));}catch (InterruptedException e) {e.printStackTrace();}list1.add(Thread.currentThread().getName());}public static void main(String args) throws InterruptedException {ThreadGroup group = new ThreadGroup("mygroup");ArrayListInThread t = new ArrayListInThread();for (int i = 0; i 《 10000; i++) {Thread th = new Thread(group, t, String.valueOf(i));th.start();}while (group.activeCount() 》 0) {Thread.sleep(10);}System.out.println();System.out.println(t.list1.size()); // it should be 10000 if thread safe collection is used.}}