java.util.concurrent.ConcurrentSkipListMap#put ( )源码实例Demo

/**
 * pollFirstEntry returns entries in order
 */
public void testPollFirstEntry() {
    ConcurrentSkipListMap map = map5();
    Map.Entry e = map.pollFirstEntry();
    assertEquals(one, e.getKey());
    assertEquals("A", e.getValue());
    e = map.pollFirstEntry();
    assertEquals(two, e.getKey());
    map.put(one, "A");
    e = map.pollFirstEntry();
    assertEquals(one, e.getKey());
    assertEquals("A", e.getValue());
    e = map.pollFirstEntry();
    assertEquals(three, e.getKey());
    map.remove(four);
    e = map.pollFirstEntry();
    assertEquals(five, e.getKey());
    try {
        e.setValue("A");
        shouldThrow();
    } catch (UnsupportedOperationException success) {}
    e = map.pollFirstEntry();
    assertNull(e);
}
 

@Test
public void testCompare() {
  Cell cell1 = getOffheapCell(row1, fam1, qual1);
  Cell cell2 = getOffheapCell(row1, fam1, qual2);
  assertTrue(CellComparatorImpl.COMPARATOR.compare(cell1, cell2) < 0);
  Cell cell3 = getOffheapCell(row1, Bytes.toBytes("wide_family"), qual2);
  assertTrue(CellComparatorImpl.COMPARATOR.compare(cell1, cell3) < 0);
  Cell cell4 = getOffheapCell(row1, Bytes.toBytes("f"), qual2);
  assertTrue(CellComparatorImpl.COMPARATOR.compare(cell1, cell4) > 0);
  BBKVComparator comparator = new BBKVComparator(null);
  assertTrue(comparator.compare(cell1, cell2) < 0);
  assertTrue(comparator.compare(cell1, cell3) < 0);
  assertTrue(comparator.compare(cell1, cell4) > 0);
  ByteBuffer buf = ByteBuffer.allocate(row1.length);
  ByteBufferUtils.copyFromArrayToBuffer(buf, row1, 0, row1.length);

  ConcurrentSkipListMap<ByteBufferKeyValue, ByteBufferKeyValue> map =
      new ConcurrentSkipListMap<>(comparator);
  map.put((ByteBufferKeyValue)cell1, (ByteBufferKeyValue)cell1);
  map.put((ByteBufferKeyValue)cell2, (ByteBufferKeyValue)cell2);
  map.put((ByteBufferKeyValue)cell3, (ByteBufferKeyValue)cell3);
  map.put((ByteBufferKeyValue)cell1, (ByteBufferKeyValue)cell1);
  map.put((ByteBufferKeyValue)cell1, (ByteBufferKeyValue)cell1);
}
 

@Override
public ConcurrentSkipListMap<Integer, E> unmarshal (IndexValue<E> value)
        throws Exception
{
    // TODO: is sorting needed?
    Collections.sort(value.list, new Comparator<E>()
             {
                 @Override
                 public int compare (E e1,
                                     E e2)
                 {
                     return Integer.compare(e1.getId(), e2.getId());
                 }
             });

    ConcurrentSkipListMap<Integer, E> map = new ConcurrentSkipListMap<>();

    for (E entity : value.list) {
        map.put(entity.getId(), entity);
    }

    return map;
}
 

private void writeOne(final WriteMetric.Request request) {
    final MetricCollection g = request.getData();

    final MemoryKey key = new MemoryKey(g.getType(), request.getSeries().getTags());

    final MemoryCell cell =
        storage.computeIfAbsent(key, k -> new MemoryCell(new ConcurrentHashMap<>()));

    final ConcurrentSkipListMap<Long, Metric> metrics = cell.getEntries()
        .computeIfAbsent(request.getSeries().getResource(),
            k -> new MemoryEntry(new ConcurrentSkipListMap<>()))
        .getMetrics();

    for (final Metric d : g.data()) {
        metrics.put(d.getTimestamp(), d);
    }
}
 

/**
 * pollFirstEntry returns entries in order
 */
public void testPollFirstEntry() {
    ConcurrentSkipListMap map = map5();
    Map.Entry e = map.pollFirstEntry();
    assertEquals(one, e.getKey());
    assertEquals("A", e.getValue());
    e = map.pollFirstEntry();
    assertEquals(two, e.getKey());
    map.put(one, "A");
    e = map.pollFirstEntry();
    assertEquals(one, e.getKey());
    assertEquals("A", e.getValue());
    e = map.pollFirstEntry();
    assertEquals(three, e.getKey());
    map.remove(four);
    e = map.pollFirstEntry();
    assertEquals(five, e.getKey());
    try {
        e.setValue("A");
        shouldThrow();
    } catch (UnsupportedOperationException success) {}
    e = map.pollFirstEntry();
    assertNull(e);
}
 

/**
 * pollLastEntry returns entries in order
 */
public void testPollLastEntry() {
    ConcurrentSkipListMap map = map5();
    Map.Entry e = map.pollLastEntry();
    assertEquals(five, e.getKey());
    assertEquals("E", e.getValue());
    e = map.pollLastEntry();
    assertEquals(four, e.getKey());
    map.put(five, "E");
    e = map.pollLastEntry();
    assertEquals(five, e.getKey());
    assertEquals("E", e.getValue());
    e = map.pollLastEntry();
    assertEquals(three, e.getKey());
    map.remove(two);
    e = map.pollLastEntry();
    assertEquals(one, e.getKey());
    try {
        e.setValue("E");
        shouldThrow();
    } catch (UnsupportedOperationException success) {}
    e = map.pollLastEntry();
    assertNull(e);
}
 

public boolean appendIndex(Map<String, PullLogIndexEntry> indexMap) {
    positionOfIndex = tablet.getWrotePosition();

    for (Map.Entry<String, PullLogIndexEntry> entry : indexMap.entrySet()) {
        final byte[] consumerBytes = entry.getKey().getBytes(StandardCharsets.UTF_8);
        int size = Integer.BYTES + Short.BYTES + consumerBytes.length + Long.BYTES + Long.BYTES + Integer.BYTES + Integer.BYTES;
        PullLogIndexEntry indexEntry = entry.getValue();

        ByteBuf buffer = ByteBufAllocator.DEFAULT.ioBuffer(size);
        try {
            buffer.writeInt(MagicCode.PULL_LOG_MAGIC_V1);
            buffer.writeShort((short) consumerBytes.length);
            buffer.writeBytes(consumerBytes);
            buffer.writeLong(indexEntry.startOfPullLogSequence);
            buffer.writeLong(indexEntry.baseOfMessageSequence);
            buffer.writeInt(indexEntry.position);
            buffer.writeInt(indexEntry.num);
            ByteBuffer nioBuffer = buffer.nioBuffer();
            Checksums.update(crc, nioBuffer, nioBuffer.limit());
            boolean result = tablet.appendData(nioBuffer);
            if (!result) return false;
        } finally {
            ReferenceCountUtil.safeRelease(buffer);
        }

        ConcurrentSkipListMap<PullLogSequence, SegmentLocation> index = sortedPullLogTable.index;
        index.put(new PullLogSequence(entry.getKey(), indexEntry.startOfPullLogSequence), new SegmentLocation(indexEntry.baseOfMessageSequence, indexEntry.position, indexEntry.num, tablet));
        tablet.retain();
    }
    return true;
}
 

/**
 * Returns a new map from Integers 1-5 to Strings "A"-"E".
 */
private static ConcurrentSkipListMap map5() {
    ConcurrentSkipListMap map = new ConcurrentSkipListMap();
    assertTrue(map.isEmpty());
    map.put(one, "A");
    map.put(five, "E");
    map.put(three, "C");
    map.put(two, "B");
    map.put(four, "D");
    assertFalse(map.isEmpty());
    assertEquals(5, map.size());
    return map;
}
 

/**
 * remove(null, x) throws NPE
 */
public void testRemove2_NullPointerException() {
    ConcurrentSkipListMap c = new ConcurrentSkipListMap();
    c.put("sadsdf", "asdads");
    try {
        c.remove(null, "whatever");
        shouldThrow();
    } catch (NullPointerException success) {}
}
 

public void addRow(String vizualizerName, AbstractGraphRow row) {
    ConcurrentSkipListMap<String, AbstractGraphRow> rows = models.get(vizualizerName);
    if (rows == null) {
        rows = getRowsMap(vizualizerName);
    }
    rows.put(row.getLabel(), row);
    notifier.refresh();
}
 

/**
 * remove(null, x) throws NPE
 */
public void testRemove2_NullPointerException() {
    ConcurrentSkipListMap c = new ConcurrentSkipListMap();
    c.put("sadsdf", "asdads");
    try {
        c.remove(null, "whatever");
        shouldThrow();
    } catch (NullPointerException success) {}
}
 

/**
 * Returns a new map from Integers 1-5 to Strings "A"-"E".
 */
private static ConcurrentNavigableMap map5() {
    ConcurrentSkipListMap map = new ConcurrentSkipListMap();
    assertTrue(map.isEmpty());
    map.put(zero, "Z");
    map.put(one, "A");
    map.put(five, "E");
    map.put(three, "C");
    map.put(two, "B");
    map.put(four, "D");
    map.put(seven, "F");
    assertFalse(map.isEmpty());
    assertEquals(7, map.size());
    return map.subMap(one, true, seven, false);
}
 

/**
 * Returns a new map from Integers 1-5 to Strings "A"-"E".
 */
private static ConcurrentNavigableMap map5() {
    ConcurrentSkipListMap map = new ConcurrentSkipListMap();
    assertTrue(map.isEmpty());
    map.put(zero, "Z");
    map.put(one, "A");
    map.put(five, "E");
    map.put(three, "C");
    map.put(two, "B");
    map.put(four, "D");
    map.put(seven, "F");
    assertFalse(map.isEmpty());
    assertEquals(7, map.size());
    return map.subMap(one, true, seven, false);
}
 

/**
 * Returns a new map from Integers -5 to -1 to Strings "A"-"E".
 */
private static ConcurrentNavigableMap dmap5() {
    ConcurrentSkipListMap map = new ConcurrentSkipListMap();
    assertTrue(map.isEmpty());
    map.put(m1, "A");
    map.put(m5, "E");
    map.put(m3, "C");
    map.put(m2, "B");
    map.put(m4, "D");
    assertFalse(map.isEmpty());
    assertEquals(5, map.size());
    return map.descendingMap();
}
 

/**
 * put(null,x) throws NPE
 */
public void testPut1_NullPointerException() {
    ConcurrentSkipListMap c = map5();
    try {
        c.put(null, "whatever");
        shouldThrow();
    } catch (NullPointerException success) {}
}
 

/**
 * Test of paintComponent method, of class GraphPanelChart.
 */
@Test
public void testPaintComponent() {
    System.out.println("paintComponent");
    Graphics g = new TestGraphics();
    GraphPanelChart instance = new GraphPanelChart();
    instance.setSize(500, 500);
    instance.getChartSettings().setDrawFinalZeroingLines(true);
    instance.getChartSettings().setDrawCurrentX(true);
    instance.getChartSettings().setExpendRows(true);

    final ConcurrentSkipListMap<String, AbstractGraphRow> rows = new ConcurrentSkipListMap<String, AbstractGraphRow>();
    instance.setRows(rows);
    final GraphRowAverages row1 = new GraphRowAverages();
    row1.setDrawThickLines(true);
    row1.setDrawLine(true);
    row1.setDrawBar(true);
    row1.setDrawValueLabel(true);
    row1.setMarkerSize(AbstractGraphRow.MARKER_SIZE_BIG);
    rows.put("test 1", row1);
    row1.add(System.currentTimeMillis(), 20);

    instance.paintComponent(g);

    row1.add(System.currentTimeMillis(), 540);
    instance.setxAxisLabelRenderer(new DateTimeRenderer("HH:mm:ss"));
    instance.paintComponent(g);

    row1.add(System.currentTimeMillis(), 8530);
    instance.paintComponent(g);
}
 

public synchronized void addProperty(Property property) {
    ConcurrentSkipListMap<String, ConcurrentSkipListSet<Property>> propertiesByKey = propertiesByNameAndKey.get(property.getName());
    if (propertiesByKey == null) {
        propertiesByKey = new ConcurrentSkipListMap<>();
        this.propertiesByNameAndKey.put(property.getName(), propertiesByKey);
    }
    ConcurrentSkipListSet<Property> properties = propertiesByKey.get(property.getKey());
    if (properties == null) {
        properties = new ConcurrentSkipListSet<>();
        propertiesByKey.put(property.getKey(), properties);
    }
    properties.add(property);
    this.propertiesList.add(property);
}
 

private ConcurrentSkipListMap<String, AbstractGraphRow> createTestModel() {
    ConcurrentSkipListMap<String, AbstractGraphRow> testModel = new ConcurrentSkipListMap<>();
    Calendar now = Calendar.getInstance();
    now.set(Calendar.HOUR_OF_DAY, 10);
    now.set(Calendar.MINUTE, 30);
    now.set(Calendar.SECOND, 0);
    now.set(Calendar.MILLISECOND, 500);

    GraphRowAverages row1 = new GraphRowAverages();
    GraphRowAverages row2 = new GraphRowAverages();
    GraphRowAverages row3 = new GraphRowAverages();

    testModel.put("row1", row1);
    testModel.put("row2", row2);
    testModel.put("row3", row3);

    row1.add(now.getTimeInMillis(), 10);
    row2.add(now.getTimeInMillis(), 20);

    now.set(Calendar.SECOND, 10);

    row1.add(now.getTimeInMillis(), 20);
    row2.add(now.getTimeInMillis(), 30);

    now.set(Calendar.SECOND, 25);

    row3.add(now.getTimeInMillis(), 50);

    return testModel;
}
 

public void generateTreeNode(DefaultMutableTreeNode parentNode) {
    DefaultMutableTreeNode nodeHeader;
    DefaultMutableTreeNode nodeTagTable;
    int lastPos;
    int diff;

    parentNode.add(nodeHeader = new DefaultMutableTreeNode(new JTreeNodeFileComponent(
            this.header.getStartPos(),
            this.header.getLength(),
            "Profile header")));
    this.header.generateTreeNode(nodeHeader);

    parentNode.add(nodeHeader = new DefaultMutableTreeNode(new JTreeNodeFileComponent(
            lastPos = this.header.getStartPos() + this.header.getLength(),
            4,
            String.format("Tag count = %d", this.tagCount))));

    lastPos = lastPos + 4;

    ConcurrentSkipListMap<Long, RefItem> sortedMap = new ConcurrentSkipListMap<Long, RefItem>();
    for (int i = 0; i < this.tagTable.length; i++) {
        parentNode.add(nodeTagTable = new DefaultMutableTreeNode(new JTreeNodeFileComponent(
                lastPos + Tag.LENGTH * i,
                Tag.LENGTH,
                String.format("Tag[%d]", i))));
        this.tagTable[i].generateTreeNode(nodeTagTable);

        if (sortedMap.get(this.tagTable[i].Offset) == null) {
            RefItem refItem = new RefItem();
            refItem.i = i;
            refItem.tag = this.tagTable[i];
            sortedMap.put(refItem.tag.Offset, refItem);
        }
    }

    lastPos = lastPos + this.tagTable.length * Tag.LENGTH;
    for (RefItem ref : sortedMap.values()) {
        diff = (int) ((this.startPos + ref.tag.Offset) - lastPos);
        if (diff > 0) {
            UITool.generateTreeNodeDiff(
                    parentNode, lastPos, diff,
                    this.rawData, this.startPos);
        }

        parentNode.add(new DefaultMutableTreeNode(new JTreeNodeFileComponent(
                this.startPos + (int) ref.tag.Offset,
                (int) ref.tag.Size,
                String.format("Data of Tag [%d]", ref.i))));
        lastPos = this.startPos + (int) ref.tag.Offset + (int) ref.tag.Size;
    }

    diff = (this.startPos + this.rawData.length) - lastPos;
    if (diff > 0) {
        UITool.generateTreeNodeDiff(
                parentNode, lastPos, diff,
                this.rawData, this.startPos);
    }
}
 

public void generateTreeNode(DefaultMutableTreeNode parentNode) {
    JTreeNodeFileComponent comp;
    DefaultMutableTreeNode nodeTiffHeader;

    // TIFF Header
    comp = new JTreeNodeFileComponent(
            this.startPos,
            TIFFHeader.SIZE,
            "TIFF Header");
    comp.setDescription("A TIFF file begins with an 8-byte image file header that points to an image file directory (IFD).");
    parentNode.add(nodeTiffHeader = new DefaultMutableTreeNode(comp));
    this.tiffHeader.generateTreeNode(nodeTiffHeader);

    // TIFF Data
    ConcurrentSkipListMap<Integer, RefItem> sortedMap = new ConcurrentSkipListMap<Integer, RefItem>();
    int lastEnd = this.tiffHeader.getStartPos() + TIFFHeader.SIZE;          // Absolute position
    int diff;

    for (IFDGroup group : this.exifGroup) {
        RefItem refItem = new RefItem();
        refItem.offset = group.offset;
        refItem.length = group.length;
        refItem.ifdgroup = group;
        sortedMap.put(refItem.offset, refItem);

        this.loadRefItem(group.ifd, sortedMap);
    }

    for (RefItem ref : sortedMap.values()) {
        diff = (this.startPos + ref.offset) - lastEnd;
        if (diff > 0) {
            UITool.generateTreeNodeDiff(
                    parentNode, lastEnd, diff,
                    this.tiffByteArray, this.startPos);
        }

        if (ref.ifdgroup != null) {
            ref.ifdgroup.generateTreeNode(parentNode);
        } else {
            parentNode.add(new DefaultMutableTreeNode(new JTreeNodeFileComponent(
                    this.tiffHeader.getStartPos() + ref.offset,
                    ref.length,
                    String.format("Reference of tag [%s] %04X.H (%d, %s)",
                            ref.ifd.getTagSpace().toString(),
                            ref.ifd.ifd_tag,
                            ref.ifd.ifd_tag,
                            ref.ifd.getTagName()))));
        }

        lastEnd = this.startPos + ref.offset + ref.length;
    }

    // In case, there is some extra space in the end
    diff = (this.tiffHeader.getStartPos() + this.tiffByteArray.length) - lastEnd;
    if (diff > 0) {
        UITool.generateTreeNodeDiff(
                parentNode, lastEnd, diff,
                this.tiffByteArray, this.startPos);
    }
}