数据结构

Author: beston123

src/main/java/code/collection/MinHeap.java

@@ -5,7 +5,7 @@
 /**
  * 〈最小堆〉<p>
  * 固定容量，解决TopK问题，满足公平性，即当值相等时，保留先放入的值
- *
+ * 复杂度：log(k)
  * @author zixiao
  * @date 2019/2/21
  */

src/main/java/code/collection/bitmap/BitMap.java

@@ -0,0 +1,63 @@
+package code.collection.bitmap;
+
+import code.collection.hashtable.HashMap;
+
+import java.util.BitSet;
+
+/**
+ * 〈位图〉<p>
+ * 〈功能详细描述〉
+ *
+ * @author zixiao
+ * @date 2019/12/16
+ */
+public class BitMap {
+
+    private BitSet bitSet;
+
+    private int capacity;
+
+    private HashMap<Integer, Integer> conflictCounter;
+
+    public BitMap(int capacity) {
+        this.capacity = capacity;
+        bitSet = new BitSet(capacity);
+        conflictCounter = new HashMap<>(capacity / 16);
+    }
+
+    public void set(int n){
+        if (get(n)) {
+            Integer count = conflictCounter.get(n);
+            if (count == null) {
+                conflictCounter.put(n, 2);
+            } else {
+                conflictCounter.put(n, ++count);
+            }
+        } else {
+            bitSet.set(n);
+        }
+    }
+
+    public boolean get(int n){
+        return bitSet.get(n);
+    }
+
+    public static void main(String[] args) {
+        int[] a = {10, 3, 4, 30, 9, 29, 60, 13, 40, 43, 3};
+        int capacity = a.length * 10;
+        BitMap bitMap = new BitMap(capacity);
+        for (int i : a) {
+            bitMap.set(i);
+        }
+        for (int i = 0; i < capacity; i++) {
+            if(bitMap.get(i)){
+                Integer count = bitMap.conflictCounter.get(i);
+                count = count == null ? 1 : count;
+                for (Integer j = 0; j < count; j++) {
+                    System.out.print(i);
+                    System.out.print("\t");
+                }
+            }
+        }
+    }
+}

src/main/java/code/collection/disruptor/LogEvent.java

@@ -0,0 +1,21 @@
+package code.collection.disruptor;
+
+/**
+ * 〈一句话功能简述〉<p>
+ * 〈功能详细描述〉
+ *
+ * @author zixiao
+ * @date 2019/9/25
+ */
+public class LogEvent {
+
+    private String value;
+
+    public String getValue() {
+        return value;
+    }
+
+    public void setValue(String value) {
+        this.value = value;
+    }
+}

src/main/java/code/collection/disruptor/LogEventFactory.java

@@ -0,0 +1,18 @@
+package code.collection.disruptor;
+
+import com.lmax.disruptor.EventFactory;
+
+/**
+ * 〈一句话功能简述〉<p>
+ * 〈功能详细描述〉
+ *
+ * @author zixiao
+ * @date 2019/9/25
+ */
+public class LogEventFactory implements EventFactory<LogEvent> {
+
+    @Override
+    public LogEvent newInstance() {
+        return new LogEvent();
+    }
+}

src/main/java/code/collection/disruptor/LogEventProducer.java

@@ -0,0 +1,30 @@
+package code.collection.disruptor;
+
+import com.lmax.disruptor.RingBuffer;
+
+/**
+ * 〈一句话功能简述〉<p>
+ * 〈功能详细描述〉
+ *
+ * @author zixiao
+ * @date 2019/9/25
+ */
+public class LogEventProducer {
+
+    private final RingBuffer<LogEvent> ringBuffer;
+
+    public LogEventProducer(RingBuffer<LogEvent> ringBuffer) {
+        this.ringBuffer = ringBuffer;
+    }
+
+    public void produce(String s) {
+        long seq = ringBuffer.next();
+        try {
+            LogEvent event = ringBuffer.get(seq);
+            event.setValue(s);
+        } finally {
+            ringBuffer.publish(seq);
+        }
+    }
+
+}

src/main/java/code/collection/disruptor/LogEventProducerWithTranslator.java

@@ -0,0 +1,28 @@
+package code.collection.disruptor;
+
+import com.lmax.disruptor.EventTranslatorOneArg;
+import com.lmax.disruptor.RingBuffer;
+
+/**
+ * 〈一句话功能简述〉<p>
+ * 〈功能详细描述〉
+ *
+ * @author zixiao
+ * @date 2019/9/25
+ */
+public class LogEventProducerWithTranslator {
+
+    private static final EventTranslatorOneArg<LogEvent, String> TRANSLATOR =
+            (event, sequence, s) -> event.setValue(s);
+
+    private final RingBuffer<LogEvent> ringBuffer;
+
+    public LogEventProducerWithTranslator(RingBuffer<LogEvent> ringBuffer) {
+        this.ringBuffer = ringBuffer;
+    }
+
+    public void produce(String s) {
+        ringBuffer.publishEvent(TRANSLATOR, s);
+    }
+
+}

src/main/java/code/collection/disruptor/LogEventTest.java

@@ -0,0 +1,130 @@
+package code.collection.disruptor;
+
+import com.lmax.disruptor.EventHandler;
+import com.lmax.disruptor.RingBuffer;
+import com.lmax.disruptor.dsl.Disruptor;
+import com.lmax.disruptor.util.DaemonThreadFactory;
+import org.apache.commons.lang3.time.StopWatch;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * 〈一句话功能简述〉<p>
+ * 〈功能详细描述〉
+ *
+ * @author zixiao
+ * @date 2019/9/25
+ */
+public class LogEventTest {
+
+    private static int THREADS = 64;
+
+    private static int PER_NUM = 1024*1024;
+
+    private static int TOTAL_NUM = THREADS*PER_NUM;
+
+    private static int CAPACITY = 4096;
+
+    private Disruptor<LogEvent> disruptor;
+
+    private LogEventProducer producer;
+
+    private AtomicInteger count = new AtomicInteger(0);
+
+    @Before
+    public void before(){
+        // The factory for the event
+        LogEventFactory factory = new LogEventFactory();
+
+        // Specify the size of the ring buffer, must be power of 2.
+        int bufferSize = CAPACITY;
+
+        // Construct the Disruptor
+        disruptor = new Disruptor<>(factory, bufferSize, DaemonThreadFactory.INSTANCE);
+
+        // Connect the handler
+        disruptor.handleEventsWith(new LogEventHandler());
+
+        // Start the Disruptor, starts all threads running
+        disruptor.start();
+
+        // Get the ring buffer from the Disruptor to be used for publishing.
+        RingBuffer<LogEvent> ringBuffer = disruptor.getRingBuffer();
+
+        this.producer = new LogEventProducer(ringBuffer);
+    }
+
+    @Test
+    public void testDisruptor() {
+        StopWatch stopWatch = new StopWatch();
+        stopWatch.start();
+        for (int t = 0; t < THREADS; t++) {
+            Thread thread = new Thread(()->{
+                for(int i=0; i<PER_NUM; i++){
+                    producer.produce("Test");
+                }
+            });
+            thread.start();
+        }
+        while (count.get() != TOTAL_NUM){}
+        stopWatch.stop();
+
+        System.out.println("Disruptor Count "+ count.get() +", cost "+ stopWatch.getTime() + "ms");
+    }
+
+    @Test
+    public void testBlockingQueue(){
+        BlockingQueue<LogEvent> queue = new ArrayBlockingQueue<LogEvent>(CAPACITY);
+        Thread consumer = new Thread(()->{
+            while (true){
+                try {
+                    LogEvent event = queue.take();
+                    count.addAndGet(1);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+        consumer.start();
+
+        StopWatch stopWatch = new StopWatch();
+        stopWatch.start();
+        for (int t = 0; t < THREADS; t++) {
+            Thread thread = new Thread(()->{
+                for(int i=0; i<PER_NUM; i++){
+                    LogEvent event = new LogEvent();
+                    event.setValue("Test");
+                    try {
+                        queue.put(event);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+                }
+            });
+            thread.start();
+        }
+        while (count.get() != TOTAL_NUM){}
+        stopWatch.stop();
+
+        System.out.println("BlockingQueue Count "+ count.get() +", cost "+ stopWatch.getTime() + "ms");
+    }
+
+    @After
+    public void after(){
+        disruptor.shutdown();
+    }
+
+    class LogEventHandler implements EventHandler<LogEvent> {
+
+        @Override
+        public void onEvent(LogEvent event, long sequence, boolean endOfBatch) throws Exception {
+            //System.out.println("Event:" + event.getValue() + ", seq:" + sequence);
+            count.addAndGet(1);
+        }
+    }
+}