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 = 0i <100000i++) {
strings.add("param1")
}
long b = System.currentTimeMillis()
// 同步方法2 装饰器模式使用 synchronized
List<String>synchronizedList = Collections.synchronizedList(names)
for (int i = 0i <100000i++) {
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的集合工具类在添加方面更加快一些,其他方法这里篇幅关系就不测试了,大家有兴趣去试一下。
在集合框架中,有些类是线程安全的,这些都是jdk1.1中的出现的。在jdk1.2之后,就出现许许多多非线程安全的类。 下面是这些线程安全的同步的类:vector:就比arraylist多了个同步化机制(线程安全),因为效率较低,现在已经不太建议使用。在web应用中,特别是前台页面,往往效率(页面响应速度)是优先考虑的。
statck:堆栈类,先进后出
hashtable:就比hashmap多了个线程安全
enumeration:枚举,相当于迭代器
除了这些之外,其他的都是非线程安全的类和接口。
线程安全的类其方法是同步的,每次只能一个访问。是重量级对象,效率较低。
其他:
1. hashtable跟hashmap的区别
hashtable是线程安全的,即hashtable的方法都提供了同步机制;hashmap不是线程安全的,即不提供同步机制 ;hashtable不允许插入空值,hashmap允许!