問題描述

Java 中有兩種類型的迭代器:fail-safe 和 fail-fast.

There are two types of iterators in Java: fail-safe and fail-fast.

這是什么意思，它們之間有什么區別?

What does this mean, and is the difference between them?

推薦答案

它們有什么區別...

What is the difference between them ...

故障安全"(在工程中)意味著某事以一種不會造成損害或造成損害最小的方式發生故障.嚴格來說，在 Java 中不存在作為故障安全迭代器的東西.如果迭代器失敗(通常意義上的失敗")，您可以預期會發生損壞.

"Fail-safe" (in engineering) means that something fails in a way that causes no or minimal damage. Strictly speaking, there is no such thing in Java as a fail-safe iterator. If an iterator fails (in the normal sense of "fail"), you can expect damage to occur.

我懷疑你的意思實際上是弱一致".迭代器.javadoc 說:

I suspect that you actually mean "weakly consistent" iterators. The javadoc says:

大多數并發 Collection 實現(包括大多數隊列)也不同于通常的 java.util 約定，因為它們的 Iterators 和 Spliterators 提供弱一致而不是快速失敗遍歷."p>

通常，弱一致性意味著如果集合與迭代同時被修改，則迭代所看到的內容的保證會更弱.(詳細信息將在每個并發集合類 javadocs 中指定.)

Typically, weak consistency means that if a collection is modified concurrently with an iteration, the guarantees of what the iteration sees are weaker. (The details will be specified in each concurrent collection classes javadocs.)

快速失敗"(在系統設計中)表示積極檢查故障條件，以便故障條件(在可能的情況下¹)在造成過多損壞之前檢測到.在 Java 中，快速失敗的迭代器會因拋出 ConcurrentModificationException 而失敗.

"Fail-fast" (in systems design) means that the failure condition is checked aggressively so that the failure condition is (where possible¹) detected before too much damage can be done. In Java, a fail-fast iterator fails by throwing a ConcurrentModificationException.

快速失敗"的替代方案；和弱一致"是迭代失敗不可預測的語義；例如有時給出錯誤的答案或拋出意外的異常.(這是早期 Java 版本中 Enumeration API 的一些標準實現的行為.)

The alternative to "fail-fast" and "weakly consistent" is semantic where the iteration fails unpredictably; e.g. to sometimes give the wrong answer or throw an unexpected exception. (This was the behavior of some standard implementations of the Enumeration API in early versions of Java.)

...它們與我們用于收集的迭代器有什么不同.

... and are they different from the iterator we use for collection.

沒有.這些是標準集合類型實現的迭代器的屬性；即它們要么快速失敗"，要么快速失敗".或弱一致"... 在同步和 Java 內存模型方面正確使用時¹.

No. These are properties of the iterators implemented by standard Collection types; i.e. they are either "fail fast" or "weakly consistent" ... when used correctly with respect to synchronization and the Java memory model¹.

快速失敗的迭代器通常使用集合對象上的 volatile 計數器實現.

Fail-fast iterators are typically implemented using a volatile counter on the collection object.

• 當集合更新時，計數器會增加.
• 創建Iterator時，計數器的當前值嵌入到Iterator對象中.
• 當執行 Iterator 操作時，該方法會比較兩個計數器值，如果它們不同則拋出 CME.

• When the collection is updated, the counter is incremented.
• When an Iterator is created, the current value of the counter is embedded in the Iterator object.
• When an Iterator operation is performed, the method compares the two counter values and throws a CME if they are different.

相比之下，弱一致性迭代器通常是輕量級的，并利用每個并發集合的內部數據結構的屬性.沒有通用模式.如果您有興趣，請閱讀不同集合類的源代碼.

By contrast, weakly consistent iterators are typically light-weight and leverage properties of each concurrent collection's internal data structures. There is no general pattern. If you are interested, read the source code for different collection classes.

^{1 - 快速失敗迭代器行為假設應用程序在同步和內存模型方面已正確實現.(換句話說，應用程序 是線程安全的.)例如，如果您在沒有正確同步的情況下迭代 ArrayList，快速失敗"會導致機制應該檢測并發修改(盡管不能保證)，但可能無法防止由于應用程序的不安全行為而損壞列表.為了說明，javadoc for Vector.iterator() 是這樣說的:}

^{1 - The rider is that fail-fast iterator behavior assumes that the application is correctly implemented with respect to synchronization and the memory model. (In other words, the application is thread-safe.) For example, if you iterated an ArrayList without proper synchronization, the "fast fail" mechanism should detect the concurrent modification (though that isn't guaranteed), but may not prevent the list from being corrupted due to the application's unsafe behavior. To illustrate, the javadoc for Vector.iterator() says this:}

^{無法保證迭代器的快速失敗行為，因為一般來說，在存在不同步的并發修改的情況下無法做出任何硬保證.快速失敗的迭代器會盡最大努力拋出 ConcurrentModificationException.因此，編寫一個依賴此異常來確保其正確性的程序是錯誤的:迭代器的快速失敗行為應僅用于檢測錯誤."}

^{"The fail-fast behavior of an iterator cannot be guaranteed as it is, generally speaking, impossible to make any hard guarantees in the presence of unsynchronized concurrent modification. Fail-fast iterators throw ConcurrentModificationException on a best-effort basis. Therefore, it would be wrong to write a program that depended on this exception for its correctness: the fail-fast behavior of iterators should be used only to detect bugs."}

這篇關于什么是故障安全&Java中的快速失敗迭代器的文章就介紹到這了，希望我們推薦的答案對大家有所幫助，也希望大家多多支持html5模板網！