|
1 /* |
|
2 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved. |
|
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
|
4 * |
|
5 * This code is free software; you can redistribute it and/or modify it |
|
6 * under the terms of the GNU General Public License version 2 only, as |
|
7 * published by the Free Software Foundation. Oracle designates this |
|
8 * particular file as subject to the "Classpath" exception as provided |
|
9 * by Oracle in the LICENSE file that accompanied this code. |
|
10 * |
|
11 * This code is distributed in the hope that it will be useful, but WITHOUT |
|
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
14 * version 2 for more details (a copy is included in the LICENSE file that |
|
15 * accompanied this code). |
|
16 * |
|
17 * You should have received a copy of the GNU General Public License version |
|
18 * 2 along with this work; if not, write to the Free Software Foundation, |
|
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
20 * |
|
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
22 * or visit www.oracle.com if you need additional information or have any |
|
23 * questions. |
|
24 */ |
|
25 |
|
26 package java.util; |
|
27 |
|
28 /** |
|
29 * This exception may be thrown by methods that have detected concurrent |
|
30 * modification of an object when such modification is not permissible. |
|
31 * <p> |
|
32 * For example, it is not generally permissible for one thread to modify a Collection |
|
33 * while another thread is iterating over it. In general, the results of the |
|
34 * iteration are undefined under these circumstances. Some Iterator |
|
35 * implementations (including those of all the general purpose collection implementations |
|
36 * provided by the JRE) may choose to throw this exception if this behavior is |
|
37 * detected. Iterators that do this are known as <i>fail-fast</i> iterators, |
|
38 * as they fail quickly and cleanly, rather that risking arbitrary, |
|
39 * non-deterministic behavior at an undetermined time in the future. |
|
40 * <p> |
|
41 * Note that this exception does not always indicate that an object has |
|
42 * been concurrently modified by a <i>different</i> thread. If a single |
|
43 * thread issues a sequence of method invocations that violates the |
|
44 * contract of an object, the object may throw this exception. For |
|
45 * example, if a thread modifies a collection directly while it is |
|
46 * iterating over the collection with a fail-fast iterator, the iterator |
|
47 * will throw this exception. |
|
48 * |
|
49 * <p>Note that fail-fast behavior cannot be guaranteed as it is, generally |
|
50 * speaking, impossible to make any hard guarantees in the presence of |
|
51 * unsynchronized concurrent modification. Fail-fast operations |
|
52 * throw {@code ConcurrentModificationException} on a best-effort basis. |
|
53 * Therefore, it would be wrong to write a program that depended on this |
|
54 * exception for its correctness: <i>{@code ConcurrentModificationException} |
|
55 * should be used only to detect bugs.</i> |
|
56 * |
|
57 * @author Josh Bloch |
|
58 * @see Collection |
|
59 * @see Iterator |
|
60 * @see Spliterator |
|
61 * @see ListIterator |
|
62 * @see Vector |
|
63 * @see LinkedList |
|
64 * @see HashSet |
|
65 * @see Hashtable |
|
66 * @see TreeMap |
|
67 * @see AbstractList |
|
68 * @since 1.2 |
|
69 */ |
|
70 public class ConcurrentModificationException extends RuntimeException { |
|
71 private static final long serialVersionUID = -3666751008965953603L; |
|
72 |
|
73 /** |
|
74 * Constructs a ConcurrentModificationException with no |
|
75 * detail message. |
|
76 */ |
|
77 public ConcurrentModificationException() { |
|
78 } |
|
79 |
|
80 /** |
|
81 * Constructs a {@code ConcurrentModificationException} with the |
|
82 * specified detail message. |
|
83 * |
|
84 * @param message the detail message pertaining to this exception. |
|
85 */ |
|
86 public ConcurrentModificationException(String message) { |
|
87 super(message); |
|
88 } |
|
89 |
|
90 /** |
|
91 * Constructs a new exception with the specified cause and a detail |
|
92 * message of {@code (cause==null ? null : cause.toString())} (which |
|
93 * typically contains the class and detail message of {@code cause}. |
|
94 * |
|
95 * @param cause the cause (which is saved for later retrieval by the |
|
96 * {@link Throwable#getCause()} method). (A {@code null} value is |
|
97 * permitted, and indicates that the cause is nonexistent or |
|
98 * unknown.) |
|
99 * @since 1.7 |
|
100 */ |
|
101 public ConcurrentModificationException(Throwable cause) { |
|
102 super(cause); |
|
103 } |
|
104 |
|
105 /** |
|
106 * Constructs a new exception with the specified detail message and |
|
107 * cause. |
|
108 * |
|
109 * <p>Note that the detail message associated with <code>cause</code> is |
|
110 * <i>not</i> automatically incorporated in this exception's detail |
|
111 * message. |
|
112 * |
|
113 * @param message the detail message (which is saved for later retrieval |
|
114 * by the {@link Throwable#getMessage()} method). |
|
115 * @param cause the cause (which is saved for later retrieval by the |
|
116 * {@link Throwable#getCause()} method). (A {@code null} value |
|
117 * is permitted, and indicates that the cause is nonexistent or |
|
118 * unknown.) |
|
119 * @since 1.7 |
|
120 */ |
|
121 public ConcurrentModificationException(String message, Throwable cause) { |
|
122 super(message, cause); |
|
123 } |
|
124 } |