并发编程修炼七:同步容器
来源:互联网 发布:知画与永琪圆房的文 编辑:程序博客网 时间:2024/05/16 14:15
作者:海子
出处:http://www.cnblogs.com/dolphin0520/
目录:
一.为什么会出现同步容器?
二.Java中的同步容器类
三.同步容器的缺陷
四.自测试
一.为什么会出现同步容器?
在Java的集合容器框架中,主要有四大类别:List、Set、Queue、Map。
List、Set、Queue接口分别继承了Collection接口,Map本身是一个接口。
注意Collection和Map是一个顶层接口,而List、Set、Queue则继承了Collection接口,分别代表数组、集合和队列这三大类容器。
像ArrayList、LinkedList都是实现了List接口,HashSet实现了Set接口,而Deque(双向队列,允许在队首、队尾进行入队和出队操作)继承了Queue接口,PriorityQueue实现了Queue接口。另外LinkedList(实际上是双向链表)实现了了Deque接口。
像ArrayList、LinkedList、HashMap这些容器都是非线程安全的。
如果有多个线程并发地访问这些容器时,就会出现问题。
因此,在编写程序时,必须要求程序员手动地在任何访问到这些容器的地方进行同步处理,这样导致在使用这些容器的时候非常地不方便。
所以,Java提供了同步容器供用户使用。
二.Java中的同步容器类
在Java中,同步容器主要包括2类:
1)Vector、Stack、HashTable
2)Collections类中提供的静态工厂方法创建的类
Vector实现了List接口,Vector实际上就是一个数组,和ArrayList类似,但是Vector中的方法都是synchronized方法,即进行了同步措施。
Stack也是一个同步容器,它的方法也用synchronized进行了同步,它实际上是继承于Vector类。
HashTable实现了Map接口,它和HashMap很相似,但是HashTable进行了同步处理,而HashMap没有。
Collections类是一个工具提供类,注意,它和Collection不同,Collection是一个顶层的接口。在Collections类中提供了大量的方法,比如对集合或者容器进行排序、查找等操作。最重要的是,在它里面提供了几个静态工厂方法来创建同步容器类,如下图所示:
三.同步容器的缺陷
从同步容器的具体实现源码可知,同步容器中的方法采用了synchronized进行了同步,那么很显然,这必然会影响到执行性能,另外,同步容器就一定是真正地完全线程安全吗?不一定,这个在下面会讲到。
我们首先来看一下传统的非同步容器和同步容器的性能差异,我们以ArrayList和Vector为例:
1.性能问题
我们先通过一个例子看一下Vector和ArrayList在插入数据时性能上的差异:
public class Test { public static void main(String[] args) throws InterruptedException { ArrayList<Integer> list = new ArrayList<Integer>(); Vector<Integer> vector = new Vector<Integer>(); long start = System.currentTimeMillis(); for(int i=0;i<100000;i++) list.add(i); long end = System.currentTimeMillis(); System.out.println("ArrayList进行100000次插入操作耗时:"+(end-start)+"ms"); start = System.currentTimeMillis(); for(int i=0;i<100000;i++) vector.add(i); end = System.currentTimeMillis(); System.out.println("Vector进行100000次插入操作耗时:"+(end-start)+"ms"); }}
这段代码在我机器上跑出来的结果是:
进行同样多的插入操作,Vector的耗时是ArrayList的两倍。
这只是其中的一方面性能问题上的反映。
另外,由于Vector中的add方法和get方法都进行了同步,因此,在有多个线程进行访问时,如果多个线程都只是进行读取操作,那么每个时刻就只能有一个线程进行读取,其他线程便只能等待,这些线程必须竞争同一把锁。
因此为了解决同步容器的性能问题,在Java 1.5中提供了并发容器,位于java.util.concurrent目录下,并发容器的相关知识将在下一篇文章中讲述。
2.同步容器真的是安全的吗?
也有有人认为Vector中的方法都进行了同步处理,那么一定就是线程安全的,事实上这可不一定。看下面这段代码:
public class Test { static Vector<Integer> vector = new Vector<Integer>(); public static void main(String[] args) throws InterruptedException { while(true) { for(int i=0;i<10;i++) vector.add(i); Thread thread1 = new Thread(){ public void run() { for(int i=0;i<vector.size();i++) vector.remove(i); }; }; Thread thread2 = new Thread(){ public void run() { for(int i=0;i<vector.size();i++) vector.get(i); }; }; thread1.start(); thread2.start(); while(Thread.activeCount()>10) { } } }}
在我机器上运行的结果:
正如大家所看到的,这段代码报错了:数组下标越界。
也许有朋友会问:Vector是线程安全的,为什么还会报这个错?很简单,对于Vector,虽然能保证每一个时刻只能有一个线程访问它,但是不排除这种可能:
当某个线程在某个时刻执行这句时:
for(int i=0;i<vector.size();i++) vector.get(i);
假若此时vector的size方法返回的是10,i的值为9
然后另外一个线程执行了这句:
for(int i=0;i<vector.size();i++) vector.remove(i);
将下标为9的元素删除了。
那么通过get方法访问下标为9的元素肯定就会出问题了。
因此为了保证线程安全,必须在方法调用端做额外的同步措施,如下面所示:
public class Test { static Vector<Integer> vector = new Vector<Integer>(); public static void main(String[] args) throws InterruptedException { while(true) { for(int i=0;i<10;i++) vector.add(i); Thread thread1 = new Thread(){ public void run() { synchronized (Test.class) { //进行额外的同步 for(int i=0;i<vector.size();i++) vector.remove(i); } }; }; Thread thread2 = new Thread(){ public void run() { synchronized (Test.class) { for(int i=0;i<vector.size();i++) vector.get(i); } }; }; thread1.start(); thread2.start(); while(Thread.activeCount()>10) { } } }}
个人认为
线程安全集合只能保证单个操作安全,复合操作同样不安全,同步容器中的所有自带方法都是线程安全的,因为方法都使用synchronized关键字标注。但是,对这些集合类的复合操作无法保证其线程安全性。需要客户端通过主动加锁来保证,就跟博主(海子)一样,在外面加关键字synchronized额外同步
查看jdk源码,会发现,像Vector这样的同步容器的所有共有方法全都是synchronized的。也就是说,我们可以在多线程场景中放心的使用单独这些方法,因为这些方法本身的确是线程安全的。那么为什么又说复合操作无法保证线程安全呢?这里举个栗子,我们定义如下删除Vector中最后一个元素方法:
public Object deleteLast(Vector v){ int lastIndex = v.size()-1; v.remove(lastIndex);}
上面这个方法是一个复合方法,包括size()和remove(),乍一看上去好像并没有什么问题,无论是size()方法还是remove()方法都是线程安全的,那么整个deleteLast方法应该也是线程安全的。但是时,如果多线程调用该方法的过程中有,remove方法有可能抛出ArrayIndexOutOfBoundsException。我们看一下remove方法具体实现,什么情况下会抛出这个异常呢。
public synchronized E remove(int index) { modCount++; if (index >= elementCount) throw new ArrayIndexOutOfBoundsException(index); E oldValue = elementData(index); int numMoved = elementCount - index - 1; if (numMoved > 0) System.arraycopy(elementData, index+1, elementData, index, numMoved); elementData[--elementCount] = null; // Let gc do its work return oldValue;}
从上面代码中可以看出,当index >= elementCount时,会抛出ArrayIndexOutOfBoundsException,也就是说,当当前索引值不再有效的时候,将会抛出这个异常。因为removeLast方法,有可能被多个线程同时执行,当线程一通过index()获得索引值为10,在尝试通过remove()删除该索引位置的元素之前,线程2把该索引位置的值删除掉了,这时线程一在执行时便会抛出异常。
为了避免出现类似问题,可以尝试加锁:
public void deleteLast() { synchronized (v) { int index = v.size() - 1; v.remove(index); }}
如上,我们在deleteLast中,对v进行加锁,即可保证同一时刻,不会有其他线程删除掉v中的元素。
Ps:由于我们自己已知Vector等同步容器是线程安全的,所以我们通常在多线程场景中会直接拿来使用,并不会考虑太多,从而可能导致问题。
所以,我们在使用同步容器的时候,如果只使用其中的自带方法,那么可以放心使用,因为他们是线程安全的,但是如果我们想做复合操作,尤其是涉及到删除容器中的元素时,一定要注意是否需要客户端主动加锁。
下面,我们考虑以下代码,如果在多线程场景中使用会不会出现线程安全问题:
for (int i = 0; i < v.size(); i++) { System.out.println(v.get(i));}
显然,以上代码在迭代的过程中,并不会出现线程安全问题。但是,如果在程序中还有以下代码有可能被同时调用呢?
for (int i = 0; i < v.size(); i++) { v.remove(i);}
由于,不同线程在同一时间操作同一个Vector,其中包括删除操作,那么就同样有可能发生线程安全问题。所以,在使用同步容器的时候,如果涉及到多个线程同时执行删除操作,就要考虑下是否需要加锁。
3.ConcurrentModificationException异常
在对Vector等容器并发地进行迭代修改时,会报ConcurrentModificationException异常,关于这个异常将会在后续文章中讲述。
但是在并发容器中不会出现这个问题。
四.自测试(效率)
根据博主(海子)的代码测试
单线程:
public class Test { private static ArrayList<Integer> arraylist = new ArrayList<Integer>(); private static Vector<Integer> vector = new Vector<Integer>(); public static void main(String[] args) throws IOException { long start = System.currentTimeMillis(); for(int i=0;i<100000;i++) arraylist.add(i); long end = System.currentTimeMillis(); System.out.println("ArrayList进行100000次插入操作耗时:"+(end-start)+"ms"); start = System.currentTimeMillis(); for(int i=0;i<100000;i++) vector.add(i); end = System.currentTimeMillis(); System.out.println("Vector进行100000次插入操作耗时:"+(end-start)+"ms"); }}
效率:
当插入数据为:100000
当插入数据为:1000000
当插入数据为:10000000 (大数据插入反而是vector效率高)
结论和原因:
Vector的性能比ArrayList数据多的时候要好,单线程的话,上锁解锁的时间可以忽略,但是,arraylist和vector都是可变数组,当容量不够的时候,arraylist是增加自身的一半,而vector是增加一倍,从这里看vector要省很多时间在增加容量上。也许这就是优势所在。
多线程:
public class Test { private static ArrayList<Integer> list = new ArrayList<Integer>(); private static Vector<Integer> vector = new Vector<Integer>(); public static void main(String[] args) throws InterruptedException { for(int i=0;i<10;i++){ Thread thread1 = new Thread(){ public void run(){ long start = System.currentTimeMillis(); for(int i=0;i<100000;i++) list.add(i); long end = System.currentTimeMillis(); System.out.println("ArrayList进行100000次插入操作耗时:"+(end-start)+"ms"); }; }; thread1.start(); } for(int i=0;i<10;i++){ Thread thread2 = new Thread(){ public void run(){ long start = System.currentTimeMillis(); for(int i=0;i<100000;i++) vector.add(i); long end = System.currentTimeMillis(); System.out.println("Vector进行100000次插入操作耗时:"+(end-start)+"ms"); }; }; thread2.start(); } }}
结果如图:
有Exception in thread “Thread-0” java.lang.ArrayIndexOutOfBoundsException异常,原因就在于ArrayList并不是线程安全的,它可能在拓展大小时,其他线程进行了add,所以会有这个异常出现。那还是要将ArrayList在synchronising环境下进行,那就没有可比性
- 并发编程修炼七:同步容器
- Java并发编程 同步容器
- Java并发编程:同步容器
- Java并发编程:同步容器
- Java并发编程:同步容器
- Java并发编程:同步容器
- Java并发编程:同步容器
- Java并发编程:同步容器
- Java并发编程:同步容器
- Java并发编程:同步容器
- Java并发编程:同步容器
- Java并发编程:同步容器
- Java并发编程:同步容器
- Java并发编程:同步容器
- Java并发编程:同步容器
- Java并发编程:同步容器
- 同步容器,并发容器(java并发编程实践读书笔记一)
- Java并发编程规则:同步容器与并发容器
- 设置label上文字显示不同大小、颜色、字体类型
- 单例模式:饿汉式、懒汉式、静态内部类式
- SpringMvc中的拦截器
- 栈 括号匹配
- jQuery中的animate
- 并发编程修炼七:同步容器
- ArrayList的坑
- 每次New一个BouncyCastleProvider导致的内存泄漏
- linux查看主机名以及更改主机名
- 《程序员面试题精选》05.输出一个字符串的所有子串
- 写在前面
- Retrofit2.0的get请求和post请求(入门级)
- 去除URL中带有的jsessionid
- leetcode: 8. String to Integer (atoi)