ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/extra166y/CustomConcurrentHashMap.java
(Generate patch)

Comparing jsr166/src/extra166y/CustomConcurrentHashMap.java (file contents):
Revision 1.10 by dl, Fri Feb 12 12:38:25 2010 UTC vs.
Revision 1.13 by jsr166, Sat Oct 16 16:40:44 2010 UTC

# Line 642 | Line 642 | public class CustomConcurrentHashMap<K,
642          int index = (hash >>> SEGMENT_SHIFT) & SEGMENT_MASK;
643          Segment seg = segs[index];
644          if (seg == null) {
645 <            synchronized(segs) {
645 >            synchronized (segs) {
646                  seg = segs[index];
647                  if (seg == null) {
648                      seg = new Segment();
# Line 1558 | Line 1558 | public class CustomConcurrentHashMap<K,
1558       * for each key-value mapping, followed by a null pair.
1559       * The key-value mappings are emitted in no particular order.
1560       */
1561 <    private void writeObject(java.io.ObjectOutputStream s) throws IOException  {
1561 >    private void writeObject(java.io.ObjectOutputStream s) throws IOException {
1562          s.defaultWriteObject();
1563          for (Map.Entry<K,V> e : entrySet()) {
1564              s.writeObject(e.getKey());
# Line 1573 | Line 1573 | public class CustomConcurrentHashMap<K,
1573       * @param s the stream
1574       */
1575      private void readObject(java.io.ObjectInputStream s)
1576 <        throws IOException, ClassNotFoundException  {
1576 >        throws IOException, ClassNotFoundException {
1577          s.defaultReadObject();
1578          this.segments = (Segment[])(new Segment[NSEGMENTS]);
1579          for (;;) {
# Line 2984 | Line 2984 | public class CustomConcurrentHashMap<K,
2984  
2985      // Temporary Unsafe mechanics for preliminary release
2986  
2987 <    static final Unsafe _unsafe;
2987 >    static final Unsafe UNSAFE;
2988      static final long tableBase;
2989      static final int tableShift;
2990      static final long segmentsBase;
# Line 3015 | Line 3015 | public class CustomConcurrentHashMap<K,
3015  
3016      static {
3017          try {
3018 <            _unsafe = getUnsafe();
3019 <            tableBase = _unsafe.arrayBaseOffset(Node[].class);
3020 <            int s = _unsafe.arrayIndexScale(Node[].class);
3018 >            UNSAFE = getUnsafe();
3019 >            tableBase = UNSAFE.arrayBaseOffset(Node[].class);
3020 >            int s = UNSAFE.arrayIndexScale(Node[].class);
3021              if ((s & (s-1)) != 0)
3022                  throw new Error("data type scale not a power of two");
3023              tableShift = 31 - Integer.numberOfLeadingZeros(s);
3024 <            segmentsBase = _unsafe.arrayBaseOffset(Segment[].class);
3025 <            s = _unsafe.arrayIndexScale(Segment[].class);
3024 >            segmentsBase = UNSAFE.arrayBaseOffset(Segment[].class);
3025 >            s = UNSAFE.arrayIndexScale(Segment[].class);
3026              if ((s & (s-1)) != 0)
3027                  throw new Error("data type scale not a power of two");
3028              segmentsShift = 31 - Integer.numberOfLeadingZeros(s);
# Line 3035 | Line 3035 | public class CustomConcurrentHashMap<K,
3035      static final  void storeNode(Node[] table,
3036                                   int i, Node r) {
3037          long nodeOffset = ((long) i << tableShift) + tableBase;
3038 <        _unsafe.putOrderedObject(table, nodeOffset, r);
3038 >        UNSAFE.putOrderedObject(table, nodeOffset, r);
3039      }
3040  
3041      static final  void storeSegment(Segment[] segs,
3042                                      int i, Segment s) {
3043          long segmentOffset = ((long) i << segmentsShift) + segmentsBase;
3044 <        _unsafe.putOrderedObject(segs, segmentOffset, s);
3044 >        UNSAFE.putOrderedObject(segs, segmentOffset, s);
3045      }
3046  
3047  

Diff Legend

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