这里那里哪里 2018-09-18
在Java的集合容器框架中,主要有四大类别:List、Set、Queue、Map。
Collection和Map是一个顶层接口,而List(数组)、Set(集合)、Queue(队列)则继承了Collection接口。
ArrayList、LinkedList都是实现了List接口,HashSet实现了Set接口,而Deque(双向队列,允许在队首、队尾进行入队和出队操作)继承了Queue接口,PriorityQueue实现了Queue接口。另外LinkedList(实际上是双向链表)实现了了Deque接口。
ArrayList、LinkedList、HashMap这些容器都是非线程安全的。如果有多个线程并发地访问这些容器时,就会出现问题。因此,在编写程序时,必须要求程序员手动地在任何访问到这些容器的地方进行同步处理,这样导致在使用这些容器的时候非常地不方便。所以,Java提供了同步容器供用户使用。
在Java中,同步容器主要包括2类:
1)Vector、Stack、HashTable
2)Collections类中提供的静态工厂方法创建的类
同步容器的具体实现源码可知,同步容器中的方法采用了synchronized进行了同步,那么很显然,这必然会影响到执行性能,另外,同步容器就一定是真正地完全线程安全吗?不一定,这个在下面会讲到。
我们首先来看一下传统的非同步容器和同步容器的性能差异,我们以ArrayList和Vector为例:
性能问题
进行同样多的插入操作,Vector的耗时是ArrayList的两倍。这只是其中的一方面性能问题上的反映。
public static void main(String[] args) throws InterruptedException { ArrayList<Integer> list = new ArrayList<>(); Vector<Integer> vector = new Vector<>(); 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"); } 运行结果: ArrayList进行100000次插入操作耗时:11ms Vector进行100000次插入操作耗时:6ms
另外,由于Vector中的add方法和get方法都进行了同步,因此,在有多个线程进行访问时,如果多个线程都只是进行读取操作,那么每个时刻就只能有一个线程进行读取,其他线程便只能等待,这些线程必须竞争同一把锁。因此为了解决同步容器的性能问题,在Java 1.5中提供了并发容器,位于java.util.concurrent目录下。
同步容器真的是安全的吗
也有人认为Vector中的方法都进行了同步处理,那么一定就是线程安全的,事实上这可不一定。看下面这段代码:
static Vector<Integer> vector = new Vector<>(); public static void main(String[] args) throws InterruptedException { while(true) { for(int i=0;i<10;i++)vector.add(i); Thread thread1 = new Thread(()->{for(int i=0;i<vector.size();i++)vector.remove(i);}); Thread thread2 = new Thread(()->{for(int i=0;i<vector.size();i++)vector.get(i);}); thread1.start(); thread2.start(); while(Thread.activeCount()>10){}//正在启动的线程不能大于10个 } }
正如大家所看到的,这段代码报错了:数组下标越界。也许有朋友会问:Vector是线程安全的,为什么还会报这个错?很简单,对于Vector,虽然能保证每一个时刻只能有一个线程访问它,但是不排除这种可能:
当某个线程在某个时刻执行vector.get(1);之前,另外一个线程恰好执行vector.remove(1);这时vector.get(1);就会抛出异常。
因此为了保证线程安全,必须在方法调用端做额外的同步措施
static Vector<Integer> vector = new Vector<>(); public static void main(String[] args) throws InterruptedException { while(true) { for(int i=0;i<10;i++)vector.add(i); Thread thread1 = new Thread(()->{synchronized (Collection1.class){for(int i=0;i<vector.size();i++)vector.remove(i);}}); Thread thread2 = new Thread(()->{synchronized (Collection1.class){for(int i=0;i<vector.size();i++)vector.get(i);}}); thread1.start(); thread2.start(); while(Thread.activeCount()>10){}//正在启动的线程不能大于10个 } }
ConcurrentModificationException异常
在对Vector等容器并发地进行迭代修改时,会报ConcurrentModificationException异常,但是在并发容器中不会出现这个问题。比如:
public static void main(String[] args) { ArrayList<Integer> list = new ArrayList<>(); list.add(2); Iterator<Integer> iterator = list.iterator(); while(iterator.hasNext()){ Integer integer = iterator.next(); if(integer==2) list.remove(integer); } }
从异常信息可以发现,异常出现在checkForComodification()方法中。我们不忙看checkForComodification()方法的具体实现。
首先看ArrayList的iterator()方法的具体实现,查看源码发现在ArrayList的源码中并没有iterator()这个方法,那么很显然这个方法应该是其父类或者实现的接口中的方法,我们在其父类AbstractList中找到了iterator()方法的具体实现,下面是其实现代码:
public Iterator<E> iterator() { return new Itr(); }
从这段代码可以看出返回的是一个指向Itr类型对象的引用,我们接着看Itr的具体实现,在AbstractList类中找到了Itr类的具体实现,它是AbstractList的一个成员内部类,下面这段代码是Itr类的所有实现:
private class Itr implements Iterator<E> { int cursor;//表示下一个要访问的元素的索引,从next()方法的具体实现就可看出 int lastRet = -1;//表示上一个访问的元素的索引 int expectedModCount = modCount;//表示对ArrayList修改次数的期望值,它的初始值为modCount。modCount是AbstractList类中的一个成员变量,该值表示对List的修改次数,查看ArrayList的add()和remove()方法就可以发现,每次调用add()方法或者remove()方法就会对modCount进行加1操作。 public boolean hasNext() { //如果下一个访问的元素下标不等于ArrayList的大小,就表示有元素需要访问,如果下一个访问元素的下标等于ArrayList的大小,则肯定到达末尾了。 return cursor != size; } @SuppressWarnings("unchecked") public E next() { checkForComodification(); int i = cursor; if (i >= size) throw new NoSuchElementException(); Object[] elementData = ArrayList.this.elementData; if (i >= elementData.length) throw new ConcurrentModificationException(); cursor = i + 1; return (E) elementData[lastRet = i];//根据i的值获取到元素.并为lastRet赋值 } //注意在使用迭代器进行迭代时,如果在迭代的过程中删除某个元素,不能直接调用List的remove。而必须调用迭代器自己提供的remove,因为调用List的remove方法后迭代器中expectedModCount以及cursor、lastRet值的正确性无法保证。 public void remove() { if (lastRet < 0)throw new IllegalStateException(); checkForComodification(); try { ArrayList.this.remove(lastRet);//调用ArrayList对象的remove cursor = lastRet;//修改cursor指针 lastRet = -1;//重置lastRet的值 expectedModCount = modCount;//重置expectedModCount的值 } catch (IndexOutOfBoundsException ex) { throw new ConcurrentModificationException(); } } ...... final void checkForComodification() { if (modCount != expectedModCount) throw new ConcurrentModificationException(); } }
通过上面代码的分析,我们可以将以上的例子修改为
public static void main(String[] args) { ArrayList<Integer> list = new ArrayList<>(); list.add(2); Iterator<Integer> iterator = list.iterator(); while(iterator.hasNext()){ Integer integer = iterator.next(); if(integer==2) iterator.remove();//注意此处 } }
上面的解决办法在单线程环境下适用,但是在多线程下适用吗?看下面一个例子:
static ArrayList<Integer> list = new ArrayList<>(); public static void main(String[] args) { list.add(1); list.add(2); list.add(3); list.add(4); list.add(5); Thread thread1 = new Thread(()->{ Iterator<Integer> iterator = list.iterator(); while(iterator.hasNext()){ System.out.println(iterator.next()); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } }); Thread thread2 = new Thread(()->{ Iterator<Integer> iterator = list.iterator(); while(iterator.hasNext()){ Integer integer = iterator.next(); if(integer==2) iterator.remove(); } }); thread1.start(); thread2.start(); }
有可能有朋友说ArrayList是非线程安全的容器,换成Vector就没问题了,实际上换成Vector还是会出现这种错误。原因在于,虽然Vector的方法采用了synchronized进行了同步,但是由于Vector是继承的AbstarctList,因此通过Iterator来访问容器的话,事实上是不需要获取锁就可以访问。那么显然,由于使用iterator对容器进行访问不需要获取锁,在多线程中就会造成当一个线程删除了元素,由于modCount是AbstarctList的成员变量,因此可能会导致在其他线程中modCount和expectedModCount值不等。
就比如上面的代码中,很显然iterator是线程私有的,初始时,线程1和线程2中的modCount、expectedModCount都为0,当线程2通过iterator.remove()删除元素时,会修改modCount值为1,并且会修改线程2中的expectedModCount的值为1,而此时线程1中的expectedModCount值为0,虽然modCount不是volatile变量,但是照样导致线程1中比较expectedModCount和modCount不等,而抛出异常。
因此一般有2种解决办法: