ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/jsr166e/ConcurrentHashMapV8.java

Comparing jsr166/src/jsr166e/ConcurrentHashMapV8.java (file contents):
Revision 1.27 by dl, Sun Oct 2 22:01:06 2011 UTC vs.
Revision 1.32 by jsr166, Sun Dec 4 01:25:16 2011 UTC

#	Line 71 | Line 71 | import java.io.Serializable;
71		* versions of this class, constructors may optionally specify an
72		* expected {@code concurrencyLevel} as an additional hint for
73		* internal sizing.  Note that using many keys with exactly the same
74	<	* {@code hashCode{}} is a sure way to slow down performance of any
74	>	* {@code hashCode()} is a sure way to slow down performance of any
75		* hash table.
76		*
77		* <p>This class and its views and iterators implement all of the
#	Line 391 | Line 391 | public class ConcurrentHashMapV8<K, V>
391		/**
392		* Key-value entry. Note that this is never exported out as a
393		* user-visible Map.Entry (see WriteThroughEntry and SnapshotEntry
394	<	* below). Nodes with a negative hash field are special, and do
394	>	* below). Nodes with a hash field of MOVED are special, and do
395		* not contain user keys or values.  Otherwise, keys are never
396		* null, and null val fields indicate that a node is in the
397		* process of being deleted or created. For purposes of read-only
#	Line 595 | Line 595 | public class ConcurrentHashMapV8<K, V>
595		} finally {
596		if (!f.casHash(fh | LOCKED, fh)) {
597		f.hash = fh;
598	<	synchronized(f) { f.notifyAll(); };
598	>	synchronized (f) { f.notifyAll(); };
599		}
600		}
601		if (validated) {
#	Line 752 | Line 752 | public class ConcurrentHashMapV8<K, V>
752		} finally {
753		if (!f.casHash(fh | LOCKED, fh)) {
754		f.hash = fh;
755	<	synchronized(f) { f.notifyAll(); };
755	>	synchronized (f) { f.notifyAll(); };
756		}
757		}
758		if (validated) {
#	Line 789 | Line 789 | public class ConcurrentHashMapV8<K, V>
789		setTabAt(tab, i, null);
790		if (!node.casHash(fh, h)) {
791		node.hash = h;
792	<	synchronized(node) { node.notifyAll(); };
792	>	synchronized (node) { node.notifyAll(); };
793		}
794		}
795		}
#	Line 843 | Line 843 | public class ConcurrentHashMapV8<K, V>
843		} finally {
844		if (!f.casHash(fh | LOCKED, fh)) {
845		f.hash = fh;
846	<	synchronized(f) { f.notifyAll(); };
846	>	synchronized (f) { f.notifyAll(); };
847		}
848		}
849		if (validated)
#	Line 934 | Line 934 | public class ConcurrentHashMapV8<K, V>
934		break;
935		}
936		}
937	+	if (val == null)
938	+	throw new NullPointerException();
939		if (added) {
940		counter.add(1L);
941		if (checkSize)
942		checkForResize();
943		}
942	–	else if (val == null)
943	–	throw new NullPointerException();
944		return val;
945		}
946
#	Line 1002 | Line 1002 | public class ConcurrentHashMapV8<K, V>
1002		} finally {
1003		if (!f.casHash(fh | LOCKED, fh)) {
1004		f.hash = fh;
1005	<	synchronized(f) { f.notifyAll(); };
1005	>	synchronized (f) { f.notifyAll(); };
1006		}
1007		}
1008		if (validated) {
#	Line 1099 | Line 1099 | public class ConcurrentHashMapV8<K, V>
1099		while ((sc = sizeCtl) >= 0) {
1100		Node[] tab = table; int n;
1101		if (tab == null || (n = tab.length) == 0) {
1102	<	n = (sc > c)? sc : c;
1102	>	n = (sc > c) ? sc : c;
1103		if (UNSAFE.compareAndSwapInt(this, sizeCtlOffset, sc, -1)) {
1104		try {
1105		if (table == tab) {
#	Line 1271 | Line 1271 | public class ConcurrentHashMapV8<K, V>
1271		} finally {
1272		if (!f.casHash(fh | LOCKED, fh)) {
1273		f.hash = fh;
1274	<	synchronized(f) { f.notifyAll(); };
1274	>	synchronized (f) { f.notifyAll(); };
1275		}
1276		}
1277		if (validated)
#	Line 1678 | Line 1678 | public class ConcurrentHashMapV8<K, V>
1678		* final String msg = ...;
1679		* map.compute(key, new RemappingFunction<Key, String>() {
1680		*   public String remap(Key k, String v) {
1681	<	*    return (v == null) ? msg : v + msg;});}</pre>
1681	>	*    return (v == null) ? msg : v + msg;});}}</pre>
1682		*
1683		* @param key key with which the specified value is to be associated
1684		* @param remappingFunction the function to compute a value
#	Line 1689 | Line 1689 | public class ConcurrentHashMapV8<K, V>
1689		* @throws IllegalStateException if the computation detectably
1690		*         attempts a recursive update to this map that would
1691		*         otherwise never complete
1692	<	* @throws RuntimeException or Error if the mappingFunction does so,
1692	>	* @throws RuntimeException or Error if the remappingFunction does so,
1693		*         in which case the mapping is unchanged
1694		*/
1695		@SuppressWarnings("unchecked")
#	Line 2187 | Line 2187 | public class ConcurrentHashMapV8<K, V>
2187		return true;
2188		}
2189
2190	<	public final boolean removeAll(Collection c) {
2190	>	public final boolean removeAll(Collection<?> c) {
2191		boolean modified = false;
2192		for (Iterator<?> it = iter(); it.hasNext();) {
2193		if (c.contains(it.next())) {
#	Line 2401 | Line 2401 | public class ConcurrentHashMapV8<K, V>
2401		}
2402		table = tab;
2403		counter.add(size);
2404	<	sc = n - (n >>> 2) - 1;
2404	>	sc = n - (n >>> 2);
2405		}
2406		} finally {
2407		sizeCtl = sc;

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines