java線程集合
⑴ java哪些集合類是線程安全的
在集合框架中，有些類是線程安全的，這些都是jdk1.1中的出現的。在jdk1.2之後，就出現許許多多非線程安全的類。 下面是這些線程安全的同步的類：
vector：就比arraylist多了個同步化機制（線程安全），因為效率較低，現在已經不太建議使用。在web應用中，特別是前台頁面，往往效率（頁面響應速度）是優先考慮的。
statck：堆棧類，先進後出
hashtable：就比hashmap多了個線程安全
enumeration：枚舉，相當於迭代器
除了這些之外，其他的都是非線程安全的類和介面。
線程安全的類其方法是同步的，每次只能一個訪問。是重量級對象，效率較低。
其他：
1. hashtable跟hashmap的區別
hashtable是線程安全的,即hashtable的方法都提供了同步機制；hashmap不是線程安全的,即不提供同步機制 ；hashtable不允許插入空值,hashmap允許!
⑵ 多線程環境下如何正確使用Java集合類
一般不要多個線程同時處理一個集合，如果非要這么做的話。
使用synchronized。對處理集合的代碼部分使用synchronized。
使用線程安全的集合類，Vector、HashTable、ConcurrentLinkedQueue、ConcurrentHashMap、CopyOnWriteArrayList、 CopyOnWriteArraySet 等。
也可以調用Collections.synchronizedMap、Collections.synchronizedList、Collections.synchronizedSet等方法使集合線程安全。
⑶ java線程安全的集合不能保證線程安全
僅能保證單個操作是線程安全的，但是迭代器則不再此列。
另外「組合操作」也是不能保證安全的。
如
if(proct.size()<10){
proct.add("obj");
}
不能保證proct.size()之後，proct.add("obj")之前，另外一個線程不add別的數據。
也不能保證
if (proct.contains("apple")) {
int index = proct.indexOf("apple");
proct.set(index, "banana");
}
確認有apple，就能查到apple的下標，即便是查到有效的下標，也不能保證set時，該下標仍然有效。
⑷ 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到一半，它也會讓位於其它在此基礎上操作的線程：
⑸ java多線程集合不適用Hashtable 的時候我們使用哪個集合
hashtable雖然是線程安全的但是效率比較低，推薦使用concurrentHashMap
⑹ java中多線程和集合先學哪個好
先學哪個沒有關系，一般教程上是先教多線程，後教集合的，因為集合里涉及到線程安全的問題，先學多線程的話，理解得透徹一些，其它沒有影響。
⑺ java 集合以及線程
如果你這個集合沒有出口，一直都往裡面塞，再多的內存也會消耗光吧，如果這樣的話，爆掉是遲早的事
⑻ 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集合 有序無序，線程是否安全
1.有序集合：集合里的元素可以根據key或index訪問；無序集合：集合里的元素只能遍歷。
有序集合在屬性的增加，刪除及修改中擁有較好的性能表現。
Set集合一般是無序的。實現hash演算法的集合一般是無序的，例如hashMap，hashTable
List集合一般是有序的。
底層是Tree的一般是有序的，例如TreeSet，TreeMap
底層有lined的一般是有序的，它會用鏈表維護元素的順序。
綜上：
有序的：List的所有子類
無序的：一般的Set，除了TreeSet，linkedHashSet等底層是樹或者鏈表的。一般的Map，除了底層是樹或者鏈表的。
已知的線程安全集合：vector，hashtable，statck，enumeration
希望可以幫到你，謝謝！
⑽ java什麼時候用多線程集合類
在遇到需要並發調用的時候.
比如在伺服器內存中有一個對象用來存儲同時在線的用戶,這時候就需要用多線程集合類,否則並發操作的時候會報出異常.