常见容错机制：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。

 
        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 
       
        } 
       
        }    
       
        }

输出：

 
        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返回的迭代器是故障安全的迭代器。

 
        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返回的迭代器。