java线程安全的集合有什么，Java哪些集合类是线程安全的
大家好，今天来为大家分享java线程安全的集合有什么的一些知识点，和Java哪些集合类是线程安全的的问题解析，大家要是都明白，那么可以忽略，如果不太清楚的话可以看看本篇文章，相信很大概率可以解决您的问题，接下来我们就一起来看看吧！
Java哪些集合类是线程安全的
在集合框架中，有些类是线程安全的，这些都是jdk1.1中的出现的。在jdk1.2之后，就出现许许多多非线程安全的类。下面是这些线程安全的同步的类：
vector：就比arraylist多了个同步化机制（线程安全），因为效率较低，现在已经不太建议使用。在web应用中，特别是前台页面，往往效率（页面响应速度）是优先考虑的。
statck：堆栈类，先进后出
hashtable：就比hashmap多了个线程安全
enumeration：枚举，相当于迭代器
除了这些之外，其他的都是非线程安全的类和接口。
线程安全的类其方法是同步的，每次只能一个访问。是重量级对象，效率较低。
其他：
1. hashtable跟hashmap的区别
hashtable是线程安全的,即hashtable的方法都提供了同步机制；hashmap不是线程安全的,即不提供同步机制；hashtable不允许插入空值,hashmap允许!
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的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.copyOf(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线程安全的集合有什么到此分享完毕，希望能帮助到您。