javalist線程安全

Ⅰ java 線程安全是什麼說說概念就行了

線程安全是指要控制多個線程對某個資源的有序訪問或修改，而在這些線程之間沒有產生沖突。
在Java里，線程安全一般體現在兩個方面：

1、多個thread對同一個java實例的訪問（read和modify）不會相互干擾，它主要體現在關鍵字synchronized。如ArrayList和Vector，HashMap和Hashtable（後者每個方法前都有synchronized關鍵字）。如果你在interator一個List對象時，其它線程remove一個element，問題就出現了。

2、每個線程都有自己的欄位，而不會在多個線程之間共享。它主要體現在java.lang.ThreadLocal類，而沒有Java關鍵字支持，如像static、transient那樣。

Ⅱ java 如何實現一個線程安全的隊列

以下是兩個線程：

import java.util.*;

public class Thread_List_Operation {
//假設有這么一個隊列
static List list = new LinkedList();

public static void main(String[] args) {
Thread t;
t = new Thread(new T1());
t.start();
t = new Thread(new T2());
t.start();

}

}

//線程T1,用來給list添加新元素
class T1 implements Runnable{

void getElemt(Object o){
Thread_List_Operation.list.add(o);
System.out.println(Thread.currentThread().getName() + "為隊列添加了一個元素");
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
getElemt(new Integer(1));
}

}

}

//線程T2,用來給list添加新元素
class T2 implements Runnable{

void getElemt(Object o){
Thread_List_Operation.list.add(o);
System.out.println(Thread.currentThread().getName() + "為隊列添加了一個元素");
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
getElemt(new Integer(1));
}

}

}

//結果（亂序）
Thread-0為隊列添加了一個元素
Thread-1為隊列添加了一個元素
Thread-0為隊列添加了一個元素
Thread-1為隊列添加了一個元素
Thread-1為隊列添加了一個元素
Thread-1為隊列添加了一個元素
Thread-1為隊列添加了一個元素
Thread-1為隊列添加了一個元素
Thread-1為隊列添加了一個元素
Thread-1為隊列添加了一個元素
Thread-1為隊列添加了一個元素
Thread-1為隊列添加了一個元素
Thread-0為隊列添加了一個元素
Thread-0為隊列添加了一個元素
Thread-0為隊列添加了一個元素
Thread-0為隊列添加了一個元素
Thread-0為隊列添加了一個元素
Thread-0為隊列添加了一個元素
Thread-0為隊列添加了一個元素
Thread-0為隊列添加了一個元素

Ⅲ java list是不是線程安全的

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

Ⅳ 在java中什麼是線程安全的

ArrayList和HashMap是非同步的，
Vector和HashTable是同步的

List本身是一個介面，有一個類叫Vector，它實現了List，並且這個Vector是線程同步的。 在實際運用中，至少我沒看見誰直接用List來裝東西，最多會是這樣:
List list = new ArrayList();
List list = new Vector();

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

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

Ⅵ 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集合中哪些類是線程安全的

線程安全類

在集合框架中，有些類是線程安全的，這些都是jdk1.1中的出現的。在jdk1.2之後，就出現許許多多非線程安全的類。 下面是這些線程安全的同步的類：

vector：就比arraylist多了個同步化機制（線程安全），因為效率較低，現在已經不太建議使用。在web應用中，特別是前台頁面，往往效率（頁面響應速度）是優先考慮的。

statck：堆棧類，先進後出

hashtable：就比hashmap多了個線程安全

enumeration：枚舉，相當於迭代器

除了這些之外，其他的都是非線程安全的類和介面。

線程安全的類其方法是同步的，每次只能一個訪問。是重量級對象，效率較低。

其他：

1. hashtable跟hashmap的區別

hashtable是線程安全的,即hashtable的方法都提供了同步機制；hashmap不是線程安全的,即不提供同步機制 ；hashtable不允許插入空值,hashmap允許!

2. 多線程並發修改一 個 集合 怎麼辦

用老的Vector/Hashtable類

StringBuffer是線程安全，而StringBuilder是線程不安全的。對於安全與不安全沒有深入的理解情況下，易造成這樣的錯覺，如果對於StringBuffer的操作均是線程安全的，然而，Java給你的保證的線程安全，是說它的方法是執行是排它的，而不是對這個對象本身的多次調用情況下，還是安全的。看看下邊的例子，在StringBufferTest中有一個數據成員contents它是用來擴展的，它的每一次append是線程安全的，但眾多次append的組合並不是線程安全的，這個輸出結果不是太可控的，但如果對於log和getContest方法加關鍵字synchronized，那麼結果就會變得非常條理，如果換成StringBuider甚至是append到一半，它也會讓位於其它在此基礎上操作的線程：