java線程安全list

❶ java的List如何實現線程安全

解決這個問題通常有兩種方法（個人認為）
一：使用synchronized關鍵字，這個大家應該都很熟悉了，不解釋了；
二：使用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適合在表中進行插入、刪除時使用，二者都是非線程安全，解決方法同上（為了避免線程安全，以上採取的方法，特別是第二種，其實是非常損耗性能的）。

❷ java list是不是線程安全的

是線程安全的，但是hashtable是全部加鎖的。
現在有更好的concurrenthashmap
這個是鎖node的。當你讀取key為某個值得時候
這個key下的value是被鎖的，但是其他的node不會被影響。

❸ Java的List如何實現線程安全

Java的List如何實現線程安全？

Collections.synchronizedList(names);效率最高，線程安全

Java的List是我們平時很常用的集合，線程安全對於高並發的場景也十分的重要，那麼List如何才能實現線程安全呢 ？

加鎖

首先大家會想到用Vector，這里我們就不討論了，首先討論的是加鎖，例如下面的代碼

public class Synchronized{

private List<String> names = new LinkedList<>();

public synchronized void addName(String name ){
names.add("abc");
}
public String getName(Integer index){
Lock lock =new ReentrantLock();
lock.lock();
try {
return names.get(index);
}catch (Exception e){
e.printStackTrace();
}
finally {
lock.unlock();
}
return null;
}
}

synchronized一加，或者使用lock 可以實現線程安全，但是這樣的List要是很多個，代碼量會大大增加。

java自帶類

在java中我找到自帶有兩種方法

CopyOnWriteArrayList

CopyOnWrite 寫入時復制，它使一個List同步的替代品，通常情況下提供了更好的並發性，並且避免了再迭代時候對容器的加鎖和復制。通常更適合用於迭代，在多插入的情況下由於多次的復制性能會一定的下降。

下面是add方法的源代碼

public boolean add(E e) {
final ReentrantLock lock = this.lock; // 加鎖 只允許獲得鎖的線程訪問
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
// 創建個長度加1的數組並復制過去
Object[] newElements = Arrays.Of(elements, len + 1);
newElements[len] = e; // 賦值
setArray(newElements); // 設置內部的數組
return true;
} finally {
lock.unlock();
}
}

Collections.synchronizedList

Collections中有許多這個系列的方法例如

主要是利用了裝飾者模式對傳入的集合進行調用 Collotions中有內部類SynchronizedList

static class SynchronizedList<E>
extends SynchronizedCollection<E>
implements List<E> {
private static final long serialVersionUID = -7754090372962971524L;

final List<E> list;

SynchronizedList(List<E> list) {
super(list);
this.list = list;
}
public E get(int index) {
synchronized (mutex) {return list.get(index);}
}
public E set(int index, E element) {
synchronized (mutex) {return list.set(index, element);}
}
public void add(int index, E element) {
synchronized (mutex) {list.add(index, element);}
}
public E remove(int index) {
synchronized (mutex) {return list.remove(index);}
}

static class SynchronizedCollection<E> implements Collection<E>, Serializable {
private static final long serialVersionUID = 3053995032091335093L;

final Collection<E> c; // Backing Collection
final Object mutex; // Object on which to synchronize

這里上面的mutex就是鎖的對象 在構建時候可以指定鎖的對象 主要使用synchronize關鍵字實現線程安全

/**
* @serial include
*/
static class SynchronizedList<E>
extends SynchronizedCollection<E>
implements List<E> {
private static final long serialVersionUID = -7754090372962971524L;

final List<E> list;

SynchronizedList(List<E> list) {
super(list);
this.list = list;
}
SynchronizedList(List<E> list, Object mutex) {
super(list, mutex);
this.list = list;
}
這里只是列舉SynchronizedList ，其他類類似，可以看下源碼了解下。

測試
public class Main {
public static void main(String[] args) {
List<String> names = new LinkedList<>();
names.add("sub");
names.add("jobs");
// 同步方法1 內部使用lock
long a = System.currentTimeMillis();
List<String> strings = new CopyOnWriteArrayList<>(names);
for (int i = 0; i < 100000; i++) {
strings.add("param1");
}
long b = System.currentTimeMillis();
// 同步方法2 裝飾器模式使用 synchronized
List<String> synchronizedList = Collections.synchronizedList(names);
for (int i = 0; i < 100000; i++) {
synchronizedList.add("param2");
}
long c = System.currentTimeMillis();
System.out.println("CopyOnWriteArrayList time == "+(b-a));
System.out.println("Collections.synchronizedList time == "+(c-b));
}
}

兩者內部使用的方法都不一樣，CopyOnWriteArrayList內部是使用lock進行加鎖解鎖完成單線程訪問，synchronizedList使用的是synchronize

進行了100000次添加後時間對比如下：

可以看出來還是使用了synchronize的集合工具類在添加方面更加快一些，其他方法這里篇幅關系就不測試了，大家有興趣去試一下。

❹ java list 怎麼定義最好

基本上來說我們用的最多的是ArrayList,LinkedList和Vector,他們的區別是：
ArrayList底層實現類似於數組，它不是線程安全的對象，但是是可變長度的，當需要增加容量時，它增加原來容量的一半，ArrayList隨機訪問List中元素的性能要優於其他List的實現。
Vector,也是可變長度的，但是它是線程安全的，而且當需要增加容量時，它增加原來容量的一倍。
LinkedList的底層實現更像一個隊列，前一個元素跟後一個元素都有指向關系，如果你需要頻繁往一個List裡面增加及刪除元素，LinkedList的性能會優於其他List的實現。
綜上所述，選擇何種List具體實現取決於應用場景。

❺ java list是不是線程安全的

直接用Vector就可以了，它是線程安全的。ArrayList list=new ArrayList();就需要鎖了，涉及同步，可以參考網上買票例子做。

❻ java線程安全的list有哪些

Hashtable、synchronizedMap、ConcurrentHashMap
二樓說的HashMap是非線程安全的

❼ java線程安全的容器有哪些

1、你是指並發操作時的線程安全嗎？
2、容器中線程安全的如：vectory,hashtable,非線程安全的如：hashmap,arrylist等。
3、對於原定義非線程的容器如：hashmap,arraylist可以使用Collections中的synchronizedList(list),synchronizedMap(map),synchronizedSet(set)等方法來使原來非線程安全的容器編程線程安全。
4、另一方面容器中使用泛型：容器<類型>也是使容器安全的一種方式。

❽ Java中StringBuffer 、ArrayList是線程安全的嗎

ArrayList不是線程安全的
你看API如果他們的方法定義裡面有synchronized證明是線程安全的
StringBuffer是線程安全的