常见容错机制：failover、failfast、failback、failsafe

1.failover：失效转移
Fail-Over的含义为“失效转移”，是一种备份操做模式，当主要组件异常时，其功能转移到备份组件。其要点在于有主有备，且主故障时备可启用，并设置为主。如Mysql的双Master模式，当正在使用的Master出现故障时，能够拿备Master作主使用

2.failfast：快速失败
从字面含义看就是“快速失败”，尽量的发现系统中的错误，使系统可以按照事先设定好的错误的流程执行，对应的方式是“fault-tolerant（错误容忍）”。以JAVA集合（Collection）的快速失败为例，当多个线程对同一个集合的内容进行操做时，就可能会产生fail-fast事件。例如：当某一个线程A经过iterator去遍历某集合的过程当中，若该集合的内容被其余线程所改变了；那么线程A访问集合时，就会抛出ConcurrentModificationException异常（发现错误执行设定好的错误的流程），产生fail-fast事件。

3.failback：失效自动恢复
Fail-over以后的自动恢复，在簇网络系统（有两台或多台服务器互联的网络）中，因为要某台服务器进行维修，须要网络资源和服务暂时重定向到备用系统。在此以后将网络资源和服务器恢复为由原始主机提供的过程，称为自动恢复

4.failsafe：失效安全
Fail-Safe的含义为“失效安全”，即便在故障的状况下也不会形成伤害或者尽可能减小伤害。维基百科上一个形象的例子是红绿灯的“冲突监测模块”当监测到错误或者冲突的信号时会将十字路口的红绿灯变为闪烁错误模式，而不是所有显示为绿灯。

————————————————
版权声明：本文为CSDN博主「青鱼入云」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处连接及本声明。
原文连接：https://blog.csdn.net/u011305680/article/details/79730646

 

failfast(快速故障):

若是出现故障，则当即报错。
一般用于非幂等性操做，如：下单操做，若是写入故障，则当即报错，没必要重试。

 

failsafe(故障安全):

若是出现故障，则能够忽略，由于这种故障不会形成损失或损失在可接受范围内。
一般用于辅助性操做，如：写入监控日志，若是写入故障，则忽略。

 

failover(故障切换):

若是出现故障，则重试备份操做模式。

一般用于幂等性操做，如：MySql的双Master模式，若是主Master故障，则切换至从Master。
重试一般会带来更多延时。

 

failback(故障恢复)：

故障切换以后，若是主要操做模式恢复，则自动从备份操做模式恢复主要操做模式。

如：MySql的双Master模式，若是主Master故障，则failover至从Master；当主Master恢复以后，则自动切换至主Master。

————————————————
版权声明：本文为CSDN博主「hanchao5272」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处连接及本声明。
原文连接：https://blog.csdn.net/hanchao5272/article/details/96439552

 

 

快速故障和故障安全系统简介：

若是系统在发生错误时当即关闭，则称为快速失败系统。这些系统不会继续出现错误。当系统发生故障时，它们会当即中止运行。故障快速系统中的错误会当即暴露出来。可是，故障安全系统并不是如此。即便系统发生故障，它们也不会中止运行。他们经过隐藏错误来继续操做。他们不会当即暴露错误。他们继续错误。哪一个系统是最好的系统，始终是系统设计领域中讨论最多的话题。在本文中，咱们将讨论限制为java中的Fail Fast和Fail Safe Iterators。

Java中的快速失败和安全失败迭代器：

Java中的迭代器使咱们可以遍历Collection对象。集合返回的迭代器本质上是  快速失败的或本质上是故障安全的。若是在迭代集合时对其进行了修改，则快速失败迭代器会当即引起  ConcurrentModificationException。在故障安全迭代器中，若是在迭代迭代集合时对其进行了修改，则不会引起任何异常。由于，它们对集合的克隆进行操做，而不对实际的集合进行操做。让咱们详细了解故障快速迭代器和故障安全迭代器。

Java中的快速失败迭代器：

大多数collection类型返回的Fail-Fast迭代器在对collection进行迭代时，不允许对collection进行任何结构性修改。（结构修改意味着添加，删除或更新集合中的元素）若是在迭代过程当中对集合进行结构化修改，则会抛出  ConcurrentModificationException。可是，若是集合是由迭代器本身的方法（如remove（））修改的，则它们不会引起任何异常。

快速迭代器如何工做？

全部Collection类型都维护一个内部对象数组（Object []）以存储元素。失败快速迭代器直接今后数组中获取元素。他们老是认为在迭代其内部元素时不会修改此内部数组。为了知道集合是否被修改，他们使用了一个称为modCount的内部标志，该标志在每次修改集合时都会更新。每当Iterator调用next（）方法时，它都会检查modCount。若是在建立此迭代器以后发现modCount 已更新，则抛出  ConcurrentModificationException。

ArrayList，Vector，HashMap等返回的迭代器本质上都是  Fail-Fast。

1个 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18岁 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

import java.util.ArrayList; import java.util.Iterator;   public class FailFastIteratorExample {            public static void main(String[] args)      {          //Creating an ArrayList of integers                    ArrayList<Integer> list = new ArrayList<Integer>();                    //Adding elements to list                    list.add( 1452 );                    list.add( 6854 );                    list.add( 8741 );                    list.add( 6542 );                    list.add( 3845 );                    //Getting an Iterator from list                    Iterator<Integer> it = list.iterator();                    while (it.hasNext())          {              Integer integer = (Integer) it.next();                            list.add( 8457 );      //This will throw ConcurrentModificationException          }      }   }

输出：

1个 2 3 4

Exception in thread "main" java.util.ConcurrentModificationException      at java.util.ArrayList$Itr.checkForComodification(Unknown Source)      at java.util.ArrayList$Itr.next(Unknown Source)      at pack1.MainClass.main(MainClass.java: 32 )

Java中的故障安全迭代器：

若是在迭代集合时对其进行了修改，则故障保护迭代器不会引起任何异常。由于，它们迭代集合的克隆而不是实际集合。所以，这些迭代器不会注意到对实际集合进行的任何结构修改。可是，这些迭代器有一些缺点。其中之一是，并不老是保证您在迭代时会得到最新数据。由于建立迭代器后对集合的任何修改都不会在迭代器中更新。这些迭代器的另外一个缺点是，就时间和内存而言，建立集合副本的开销会更大。

ConcurrentHashMap返回的迭代器是故障安全的迭代器。

1个 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18岁 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

import java.util.Iterator; import java.util.concurrent.ConcurrentHashMap;   public class FailSafeIteratorExample {            public static void main(String[] args)      {          //Creating a ConcurrentHashMap                    ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<String, Integer>();                    //Adding elements to map                    map.put( "ONE" , 1 );                    map.put( "TWO" , 2 );            map.put( "THREE" , 3 );                    map.put( "FOUR" , 4 );                    //Getting an Iterator from map                    Iterator<String> it = map.keySet().iterator();                    while (it.hasNext())          {              String key = (String) it.next();                            System.out.println(key+ " : " +map.get(key));                            map.put( "FIVE" , 5 );     //This will not be reflected in the Iterator          }      }   }

输出：

二：
二四：四
一：
三：3

快速失败与Java中的失败安全迭代器：

失败快速迭代器	故障安全迭代器
失败快速迭代器不容许在对集合进行迭代时对其进行修改。	故障保护迭代器容许在对集合进行迭代时对其进行修改。
若是在迭代集合时对其进行了修改，则这些迭代器将引起ConcurrentModificationException。	若是在迭代集合时对其进行了修改，则这些迭代器不会引起任何异常。
他们使用原始集合遍历集合的元素。	他们使用原始集合的副本遍历集合的元素。
这些迭代器不须要额外的内存。	这些迭代器须要额外的内存来克隆集合。
例如：ArrayList，Vector，HashMap返回的迭代器。	例如：ConcurrentHashMap返回的迭代器。