程序博客网 > plc有仿真软件

Java中的fail-fast机制（基于JDK1.8）

来源：互联网 发布：plc有仿真软件 编辑：程序博客网 时间：2024/05/12 00:18
fail-fast简介

fail-fast 机制是java集合(Collection)中的一种错误机制。当多个线程对同一个集合的内容进行操作时，就可能会产生fail-fast事件。
例如：当某一个线程A通过iterator去遍历某集合的过程中，若该集合的内容被其他线程所改变了；那么线程A访问集合时，就会抛出ConcurrentModificationException异常，产生fail-fast事件。

在详细介绍fail-fast机制的原理之前，先通过一个示例来认识fail-fast。

  1. import java.util.*;
  2. import java.util.concurrent.*;
  4. /*
  5.  * @desc java集合中Fast-Fail的测试程序。
  6.  *
  7.  *   fast-fail事件产生的条件：当多个线程对Collection进行操作时，若其中某一个线程通过iterator去遍历集合时，该集合的内容被其他线程所改变；则会抛出ConcurrentModificationException异常。
  8.  *   fast-fail解决办法：通过util.concurrent集合包下的相应类去处理，则不会产生fast-fail事件。
  9.  *
  10.  *   本例中，分别测试ArrayList和CopyOnWriteArrayList这两种情况。ArrayList会产生fast-fail事件，而CopyOnWriteArrayList不会产生fast-fail事件。
  11.  *   (01) 使用ArrayList时，会产生fast-fail事件，抛出ConcurrentModificationException异常；定义如下：
  12.  *            private static List<String> list = new ArrayList<String>();
  13.  *   (02) 使用时CopyOnWriteArrayList，不会产生fast-fail事件；定义如下：
  14.  *            private static List<String> list = new CopyOnWriteArrayList<String>();
  15.  *
  16.  */
  17. public class FastFailTest {
  19.     private static List<String> list = new ArrayList<String>();
  20.     //private static List<String> list = new CopyOnWriteArrayList<String>();
  21.     public static void main(String[] args) {
  23.         // 同时启动两个线程对list进行操作！
  24.         new ThreadOne().start();
  25.         new ThreadTwo().start();
  26.     }
  28.     private static void printAll() {
  29.         System.out.println("");
  31.         String value = null;
  32.         Iterator iter = list.iterator();
  33.         while(iter.hasNext()) {
  34.             value = (String)iter.next();
  35.             System.out.print(value+", ");
  36.         }
  37.     }
  39.     /**
  40.      * 向list中依次添加0,1,2,3,4,5，每添加一个数之后，就通过printAll()遍历整个list
  41.      */
  42.     private static class ThreadOne extends Thread {
  43.         public void run() {
  44.             int i = 0;
  45.             while (i<6) {
  46.                 list.add(String.valueOf(i));
  47.                 printAll();
  48.                 i++;
  49.             }
  50.         }
  51.     }
  53.     /**
  54.      * 向list中依次添加10,11,12,13,14,15，每添加一个数之后，就通过printAll()遍历整个list
  55.      */
  56.     private static class ThreadTwo extends Thread {
  57.         public void run() {
  58.             int i = 10;
  59.             while (i<16) {
  60.                 list.add(String.valueOf(i));
  61.                 printAll();
  62.                 i++;
  63.             }
  64.         }
  65.     }
  67. }

第一次运行后，出现如下结果（在ThreadOne的代码中抛出异常）。
控制台输出：
0, 10, 
0, 10, 11, 
0, 10, 11, 12, 
0, 10, 11, 12, 13, 
0, 10, 11, 12, 13, 14, 
Exception in thread "Thread-0" java.util.ConcurrentModificationException
0, 10, 11, 12, 13, 14, 15, at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
at java.util.ArrayList$Itr.next(ArrayList.java:851)
at com.anyco.failfast.FastFailTest.printAll(FastFailTest.java:36)
at com.anyco.failfast.FastFailTest.access$300(FastFailTest.java:19)
at com.anyco.failfast.FastFailTest$ThreadOne.run(FastFailTest.java:49)


第二次运行后，出现如下结果（在ThreadTwo的代码中抛出异常）。
控制台输出：
Exception in thread "Thread-1" java.util.ConcurrentModificationException

at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
0, 0, 
at java.util.ArrayList$Itr.next(ArrayList.java:851)
0, 1, 
at com.anyco.failfast.FastFailTest.printAll(FastFailTest.java:36)
0, 1, 2, 
at com.anyco.failfast.FastFailTest.access$300(FastFailTest.java:19)
0, 1, 2, 3, 
at com.anyco.failfast.FastFailTest$ThreadTwo.run(FastFailTest.java:63)
0, 1, 2, 3, 4, 
0, 1, 2, 3, 4, 5, 

如果运行时没有出现异常，多运行几次。

结果说明：
在这里list是FastFailTest 的成员变量，我们通过
  1.  new ThreadOne().start();
  2.  new ThreadTwo().start();
启动了两个新的线程来对list进行修改，ThreadOne向list中依次添加0,1,2,3,4,5，每添加一个数之后，就通过printAll()遍历整个list，ThreadTwo向list中依次添加10,11,12,13,14,15，每添加一个数之后，就通过printAll()遍历整个list，当某一个线程遍历list的过程中，list的内容被另外一个线程所改变了，就会抛出ConcurrentModificationException异常，产生fail-fast事件。


为何产生ConcurrentModificationException
由于我们采用的是ArrayList做的测试，所以查看ArrayList源码即可，在上面抛出异常的输出中你会发现异常是出现在checkForComodification方法里面的，具体是在调用ArrayList$Itr.next方法的时候会调用checkForComodification方法，进而产生异常，那么这里的Itr又是什么呢？查看源码发现他是ArrayList的私有内部类，我们在调用ArrayList的iterator方法的时候会创建一个Itr对象出来：

  1. public Iterator<E> iterator() {
  2.         return new Itr();
  3.     }

  1. private class Itr implements Iterator<E> {
  2.         int cursor;       // index of next element to return
  3.         int lastRet = -1; // index of last element returned; -1 if no such
  4.         int expectedModCount = modCount;
  6.         public boolean hasNext() {
  7.             return cursor != size;
  8.         }
  10.         @SuppressWarnings("unchecked")
  11.         public E next() {
  12.             checkForComodification();
  13.             int i = cursor;
  14.             if (i >= size)
  15.                 throw new NoSuchElementException();
  16.             Object[] elementData = ArrayList.this.elementData;
  17.             if (i >= elementData.length)
  18.                 throw new ConcurrentModificationException();
  19.             cursor = i + 1;
  20.             return (E) elementData[lastRet = i];
  21.         }
  23.         public void remove() {
  24.             if (lastRet < 0)
  25.                 throw new IllegalStateException();
  26.             checkForComodification();
  28.             try {
  29.                 ArrayList.this.remove(lastRet);
  30.                 cursor = lastRet;
  31.                 lastRet = -1;
  32.                 expectedModCount = modCount;
  33.             } catch (IndexOutOfBoundsException ex) {
  34.                 throw new ConcurrentModificationException();
  35.             }
  36.         }
  38.         @Override
  39.         @SuppressWarnings("unchecked")
  40.         public void forEachRemaining(Consumer<? super E> consumer) {
  41.             Objects.requireNonNull(consumer);
  42.             final int size = ArrayList.this.size;
  43.             int i = cursor;
  44.             if (i >= size) {
  45.                 return;
  46.             }
  47.             final Object[] elementData = ArrayList.this.elementData;
  48.             if (i >= elementData.length) {
  49.                 throw new ConcurrentModificationException();
  50.             }
  51.             while (i != size && modCount == expectedModCount) {
  52.                 consumer.accept((E) elementData[i++]);
  53.             }
  54.             // update once at end of iteration to reduce heap write traffic
  55.             cursor = i;
  56.             lastRet = i - 1;
  57.             checkForComodification();
  58.         }
  60.         final void checkForComodification() {
  61.             if (modCount != expectedModCount)
  62.                 throw new ConcurrentModificationException();
  63.         }
  64.     }

此句代码int expectedModCount = modCount;很重要，modCount是指list在结构上被改变的次数当然也包括list中内容顺序发生改变的次数，这个值的修改会使得迭代器产生不正确的结果，如果你查看ArrayList中modCount值哪里发生过修改的话，一般出现在add、remove、clear中。
在Itr的三种重要的方法中，都需要checkForComodification。
  1.  final void checkForComodification() {
  2.             if (modCount != expectedModCount)
  3.                 throw new ConcurrentModificationException();
  4.         }
由此可知，如果if (modCount != expectedModCount)成立，则会抛出ConcurrentModificationException的异常。expectedModCount的值是我们在开始迭代的时候赋值的，modCount有可能在我们迭代的过程中因为我们向ArrayList中添加或者删除元素而发生变化，这就会导致两者值不等了，也就是modCount != expectedModCount的情况了。
在最开始的demo中，我们用两个线程对同一个List进行操作，倘若在ThreadOne进行遍历list集合时，ThreadTwo对此对象进行了操作，则会导致
modCount != expectedModCount，因此也就抛出了ConcurrentModificationException的异常，ThreadTwo对list集合遍历时，抛出异常原理也如此。


如何解决fail-fast的问题
ArrayList是个线程不安全的类，我们可以通过使用concurrent包下的另一个类CopyOnWriteArrayList来替换它。
  1. public class CopyOnWriteArrayList<E>
  2.     implements List<E>, RandomAccess, Cloneable, java.io.Serializable
  1. public class ArrayList<E> extends AbstractList<E>
  2.         implements List<E>, RandomAccess, Cloneable, java.io.Serializable
CopyOnWriteArrayList与ArrayList的重要不同在于，CopyOnWriteArrayList没有继承AbstractList。

对于CopyOnWriteArrayList，其iterator遍历方式如下
  1. public Iterator<E> iterator() {
  2.         return new COWIterator<E>(getArray(), 0);
  3.     }

  1. static final class COWIterator<E> implements ListIterator<E> {
  2.         /** Snapshot of the array */
  3.         private final Object[] snapshot;
  4.         /** Index of element to be returned by subsequent call to next.  */
  5.         private int cursor;
  7.         private COWIterator(Object[] elements, int initialCursor) {
  8.             cursor = initialCursor;
  9.             snapshot = elements;
  10.         }
  12.         public boolean hasNext() {
  13.             return cursor < snapshot.length;
  14.         }
  16.         public boolean hasPrevious() {
  17.             return cursor > 0;
  18.         }
  20.         @SuppressWarnings("unchecked")
  21.         public E next() {
  22.             if (! hasNext())
  23.                 throw new NoSuchElementException();
  24.             return (E) snapshot[cursor++];
  25.         }
  27.         @SuppressWarnings("unchecked")
  28.         public E previous() {
  29.             if (! hasPrevious())
  30.                 throw new NoSuchElementException();
  31.             return (E) snapshot[--cursor];
  32.         }
  34.         public int nextIndex() {
  35.             return cursor;
  36.         }
  38.         public int previousIndex() {
  39.             return cursor-1;
  40.         }
  42.         
  43.         public void remove() {
  44.             throw new UnsupportedOperationException();
  45.         }
  47.         
  48.         public void set(E e) {
  49.             throw new UnsupportedOperationException();
  50.         }
  52.        
  53.         public void add(E e) {
  54.             throw new UnsupportedOperationException();
  55.         }
  57.         @Override
  58.         public void forEachRemaining(Consumer<? super E> action) {
  59.             Objects.requireNonNull(action);
  60.             Object[] elements = snapshot;
  61.             final int size = elements.length;
  62.             for (int i = cursor; i < size; i++) {
  63.                 @SuppressWarnings("unchecked") E e = (E) elements[i];
  64.                 action.accept(e);
  65.             }
  66.             cursor = size;
  67.         }
  68.     }

private final Object[] snapshot;用来保存要遍历的list的快照。
  1. private COWIterator(Object[] elements, int initialCursor) {
  2.             cursor = initialCursor;
  3.             snapshot = elements;
  4.         }
CopyOnWriteArrayList的底层实现仍然是一个数组，新建COWIterator时，将集合中的元素保存到一个新的拷贝数组中。 这样，当原始集合的数据改变，拷贝数据中的值也不会变化。


CopyOnWriteArrayList的并发问题
先看CopyOnWriteArrayList的几个重要的接口
  1. public boolean add(E e) {
  2.         final ReentrantLock lock = this.lock;
  3.         lock.lock();
  4.         try {
  5.             Object[] elements = getArray();
  6.             int len = elements.length;
  7.             Object[] newElements = Arrays.copyOf(elements, len + 1);
  8.             newElements[len] = e;
  9.             setArray(newElements);
  10.             return true;
  11.         } finally {
  12.             lock.unlock();
  13.         }
  14.     }

  1. public void add(int index, E element) {
  2.         final ReentrantLock lock = this.lock;
  3.         lock.lock();
  4.         try {
  5.             Object[] elements = getArray();
  6.             int len = elements.length;
  7.             if (index > len || index < 0)
  8.                 throw new IndexOutOfBoundsException("Index: "+index+
  9.                                                     ", Size: "+len);
  10.             Object[] newElements;
  11.             int numMoved = len - index;
  12.             if (numMoved == 0)
  13.                 newElements = Arrays.copyOf(elements, len + 1);
  14.             else {
  15.                 newElements = new Object[len + 1];
  16.                 System.arraycopy(elements, 0, newElements, 0, index);
  17.                 System.arraycopy(elements, index, newElements, index + 1,
  18.                                  numMoved);
  19.             }
  20.             newElements[index] = element;
  21.             setArray(newElements);
  22.         } finally {
  23.             lock.unlock();
  24.         }
  25.     }

  1. public E remove(int index) {
  2.         final ReentrantLock lock = this.lock;
  3.         lock.lock();
  4.         try {
  5.             Object[] elements = getArray();
  6.             int len = elements.length;
  7.             E oldValue = get(elements, index);
  8.             int numMoved = len - index - 1;
  9.             if (numMoved == 0)
  10.                 setArray(Arrays.copyOf(elements, len - 1));
  11.             else {
  12.                 Object[] newElements = new Object[len - 1];
  13.                 System.arraycopy(elements, 0, newElements, 0, index);
  14.                 System.arraycopy(elements, index + 1, newElements, index,
  15.                                  numMoved);
  16.                 setArray(newElements);
  17.             }
  18.             return oldValue;
  19.         } finally {
  20.             lock.unlock();
  21.         }
  22.     }

毫无疑问CopyOnWriteArrayList在添加和remove元素的时候，都通过ReentrantLock加了锁，同一时刻对该list的添加、删除元素只能有一个线程在执行。
对public boolean add(E e)方法来说，同一时间只能有一个线程在添加元素。然后使用Arrays.copyOf(...)方法复制出另一个新的数组，而且新的数组的长度比原来数组的长度+1，副本复制完毕，新添加的元素也赋值添加完毕，最后又把新的副本数组赋值给了旧的数组，最后在finally语句块中将锁释放。
public E remove(int index)，删除指定位置的元素，先判断要删除的元素是否最后一个，如果最后一个直接在复制副本数组的时候，复制长度为旧数组的length-1即可；但是如果不是最后一个元素，就先复制旧的数组的index前面元素到新数组中，然后再复制旧数组中index后面的元素到数组中，最后再把新数组复制给旧数组的引用。
最后在finally语句块中将锁释放。


CopyOnWriteArrayList的性能问题
优点:
1.解决的开发工作中的多线程的并发问题。
缺点:
1.内存占有问题:很明显，两个数组同时驻扎在内存中，如果实际应用中，数据比较多，而且比较大的情况下，占用内存会比较大，针对这个其实可以用ConcurrentHashMap来代替。
2.数据一致性:CopyOnWriteArrayList容器只能保证数据的最终一致性，不能保证数据的实时一致性。所以如果你希望写入的数据，马上能读到，请不要使用CopyOnWriteArrayList容器，因为每次添加删除元素后，都需要经过一次拷贝数组的过程。





阅读全文
0 0
plc有仿真软件 plc有仿真软件
原创粉丝点击
热门IT博客
淘宝网店怎么收藏淘宝网店怎么收藏
淘宝店铺转让骗局淘宝店铺转让骗局
信息处理技术员软件
办公自动化软件好学吗
java和web前端的区别
知无涯生有涯
pid控制算法公式详解
迷你图书管理系统java
js new array 长度
linux rpm
知乐小说作品集
破解软件盒子下载
淘宝调研网站
王权富贵东方月初乐乎
地图信息编辑软件
网络嗅探工具
调查问卷数据分析软件
sql语句合计 排序
php获取对象的属性值
网络博客真的能赚钱吗
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 富士通900 富士通u1010 富士通存储 富士通联系电话 富士通集团 富士通890 富士通400电话 富士通服务器 富士通台式电脑 富士通dpk8300e 富士通售后电话 富士通2050 富士通s510 富士通空气净化 富士通磁带库 富士通系列 富士通指纹 富士通硬盘 富士通6110 富士通310 富士通代理商 富士通厂 富士通拍立得 富士通压缩机 富士通笔记本ah544 富士通dpk 富士通报价 富士通硬盘多少钱 富士通1620 富士通家具 富士通 s2210 富士通 代理 富士通净化器 富士通价格 富士通将军价格 富士通6770 富士通1080 富士通dpk9500ga 富士通门禁 富士通商务本 富士通dpk8300e+

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里