suporta dois tipos de iteradores, o primeiro é fail fast e o segundo é fail safe. Eles desempenham um papel vital quando se trata de tratamento de exceções em Java. Neste artigo sobre 'Iteradores com falha rápida e sem falhas', analisaremos o funcionamento dos dois iteradores, bem como a diferença essencial entre eles.
A seguir estão as dicas a serem discutidas neste artigo:
elevando um número a uma potência em java
- Modificações Simultâneas
- Fail Fast Iterator
- Iterador à prova de falhas
- Iterator Fail Fast vs Fail Safe
Antes de entrar em uma explicação detalhada, vamos nos familiarizar com o conceito de Modificação Simultânea.
Modificação Simultânea
Quando um único thread (ou vários threads) itera sobre uma coleção, ele pode alterar a estrutura da coleção, adicionando ou excluindo o elemento na coleção ou atualizando o valor do elemento em uma posição específica. Este processo é conhecido como modificação simultânea.
Vamos rapidamente dar uma olhada nos dois sistemas que dizem respeito ao tópico acima, antes de entrar nos detalhes do mesmo,
Falha no sistema rápido:
Um sistema é rotulado como um sistema rápido de falha, se ele for encerrado imediatamente após a ocorrência de um erro. As operações são abortadas instantaneamente e as falhas ou erros são expostos.
Sistema à prova de falhas:
Um sistema é rotulado como um sistema à prova de falhas, se continuar a operar mesmo após a ocorrência de uma falha ou erro. Eles não abortam uma operação e escondem os erros em vez de expô-los.
Iteradores em java nos permitem percorrer os objetos Collection. Os iteradores retornados pela coleção são fail fast ou fail safe por natureza.
Fail Fast Iterator
Os iteradores rápidos em Java não permitem qualquer tipo de modificação estrutural em uma coleção durante a iteração sobre ela. A Modificação Estrutural inclui adicionar, remover ou atualizar qualquer elemento na coleção durante a iteração sobre ele. O iterador lança uma ConcurrentModificationException, se uma coleção for modificada estruturalmente durante o processo de iteração.
No entanto, deve-se notar que se um item for removido usando o próprio método dos iteradores, ou seja, o método remove (), nenhuma exceção é lançada. É um processo totalmente seguro. Assegure-se de ter java instalado no seu sistema
Exemplo de Iterador Fail Fast:
import java.util.HashMap import java.util.Iterator import java.util.Map public class FailFastExample {public static void main (String [] args) {Map monthIndex = new HashMap () monthIndex.put ('1', 'Janeiro ') monthIndex.put (' 2 ',' fevereiro ') monthIndex.put (' 3 ',' março ') Iterator iterator = monthIndex.keySet (). iterator () while (iterator.hasNext ()) {System.out .println (monthIndex.get (iterator.next ())) // adicionar um elemento ao Mapa // exceção será lançada na próxima chamada // do método next (). monthIndex.put ('4', 'abril')}}}Resultado:
Exceção no thread “main” java.util.ConcurrentModificationException
em java.util.HashMap $ HashIterator.nextEntry (fonte desconhecida)
Agora, vamos dar uma olhada no Iterator Fail Safe,
Iterador à prova de falhas
Ao contrário dos iteradores Fail Fast, os iteradores Fail Safe não lançam nenhuma exceção se a coleção for modificada durante o processo de iteração. Isso se deve ao fato de que eles iteram no clone da coleção, e não na coleção real. As modificações estruturais feitas na coleção real passam despercebidas por eles.
o que o init faz em python
No entanto, deve-se observar que não existe realmente um Iterador à prova de falhas. Seria apropriado denominá-lo como Fracamente Consistente. Isso simplesmente significa que E se uma Coleção é modificada durante o processo de iteração, o que o Repetidor vê é fracamente garantido. Esse comportamento difere para diferentes coleções e está documentado em Javadocs.
Exemplo de Iterador à prova de falhas:
public class FailSafeExample {public static void main (String [] args) {ConcurrentMap monthIndex = new ConcurrentHashMap () monthIndex.put ('1', 'Janeiro') monthIndex.put ('2', 'Fevereiro') monthIndex.put ( '3', 'Março') Iterator iterator = monthIndex.keySet (). Iterator () while (iterator.hasNext ()) {System.out.println (monthIndex.get (iterator.next ())) monthIndex.put ( '4', 'abril')}}}Resultado:
- janeiro
- fevereiro
- Março
Finalmente, neste artigo, estaríamos comparando esses iteradores,
Diferenças: Iterator Fail Fast e Fail Safe
A seguir estão as diferenças essenciais entre os dois iteradores:
| Parâmetros | Fail Fast Iterator | Iterador à prova de falhas |
| Lançar ConcurrentModification Exception | Sim, eles lançam CocurrentModificationExcepti-on se uma coleção for modificada durante a iteração sobre ela. | Não, eles não lançam nenhuma exceção se uma coleção for modificada durante a iteração sobre ela. |
| Clone a coleção | Não, eles usam a coleção original para percorrer os elementos. | Sim, eles usam a cópia da coleção original para atravessar. |
| Sobrecarga de memória | Não, eles não requerem memória extra. | Sim, eles exigem memória extra para clonar a coleção. |
| Exemplos | HashMap, Vector, ArrayList, HashSet c ++ o que é namespace | CopyOnWriteArrayList |
Esses iteradores são únicos e muito necessários na versátil linguagem Java. Embora o fail safe tenha um toque reconfortante, o iterador fail fast prova ser robusto.
Isso traz ao final deste artigo. caso você queira saber mais, verifique o por Edureka. O curso de certificação e treinamento Java J2EE e SOA da Edureka foi projetado para dar a você uma vantagem na programação Java e treiná-lo para os conceitos básicos e avançados do Java, juntamente com vários frameworks Java como Hibernate e Spring.
Tem alguma questão para nós? Mencione isso na seção de comentários deste blog “Fail Fast vs Fail Safe” e entraremos em contato com você o mais breve possível.