Add files via upload

Author: jdbirla

Java_Multithreading_Concurrency/Michael Pogrebinsky/JdMultiThreadPerformance/src/main/java/com/jd/thread/BlockingIO/IoBoundApplication.java

@@ -0,0 +1,44 @@
+package com.jd.thread.BlockingIO;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+public class IoBoundApplication {
+    private static final int NUMBER_OF_TASKS = 10_0000;
+
+    public static void main(String[] args) {
+        System.out.printf("Running %d tasks\n", NUMBER_OF_TASKS);
+
+        long start = System.currentTimeMillis();
+        performTasks();
+        System.out.printf("Tasks took %dms to complete\n", System.currentTimeMillis() - start);
+    }
+
+    private static void performTasks() {
+        try (ExecutorService executorService = Executors.newCachedThreadPool()) {
+
+            for (int i = 0; i < NUMBER_OF_TASKS; i++) {
+                executorService.submit(() ->  blockingIoOperation());
+            }
+        }
+//        ExecutorService executor = Executors.newFixedThreadPool(1000);
+//
+//        for (int i = 0; i < NUMBER_OF_TASKS; i++) {
+//            Future<?> submit = executor.submit(() -> blockingIoOperation());
+//
+//        }
+//        executor.shutdown();
+
+    }
+
+    // Simulates a long blocking IO
+    private static void blockingIoOperation() {
+        System.out.println("Executing a blocking task from thread: " + Thread.currentThread());
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

Java_Multithreading_Concurrency/Michael Pogrebinsky/JdMultiThreadPerformance/src/main/java/com/jd/thread/LockFree/AotmicReferenceEx.java

@@ -0,0 +1,134 @@
+package com.jd.thread.LockFree;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.concurrent.locks.LockSupport;
+
+public class AotmicReferenceEx {
+    public static void main(String[] args) throws InterruptedException {
+        StandardStack<Integer> stack = new StandardStack<>();
+       // LockFreeStack<Integer> stack = new LockFreeStack<>();
+        Random random = new Random();
+
+        for (int i = 0; i < 100000; i++) {
+            stack.push(random.nextInt());
+        }
+
+        List<Thread> threads = new ArrayList<>();
+
+        int pushingThreads = 2;
+        int poppingThreads = 2;
+
+        for (int i = 0; i < pushingThreads; i++) {
+            Thread thread = new Thread(() -> {
+                while (true) {
+                    stack.push(random.nextInt());
+                }
+            });
+
+            thread.setDaemon(true);
+            threads.add(thread);
+        }
+
+        for (int i = 0; i < poppingThreads; i++) {
+            Thread thread = new Thread(() -> {
+                while (true) {
+                    stack.pop();
+                }
+            });
+
+            thread.setDaemon(true);
+            threads.add(thread);
+        }
+
+        for (Thread thread : threads) {
+            thread.start();
+        }
+
+        Thread.sleep(10000);
+
+        System.out.println(String.format("%,d operations were performed in 10 seconds ", stack.getCounter()));
+    }
+
+    public static class LockFreeStack<T> {
+        private AtomicReference<StackNode<T>> head = new AtomicReference<>();
+        private AtomicInteger counter = new AtomicInteger(0);
+
+        public void push(T value) {
+            StackNode<T> newHeadNode = new StackNode<>(value);
+
+            while (true) {
+                StackNode<T> currentHeadNode = head.get();
+                newHeadNode.next = currentHeadNode;
+                if (head.compareAndSet(currentHeadNode, newHeadNode)) {
+                    break;
+                } else {
+                    LockSupport.parkNanos(1);
+                }
+            }
+            counter.incrementAndGet();
+        }
+
+        public T pop() {
+            StackNode<T> currentHeadNode = head.get();
+            StackNode<T> newHeadNode;
+
+            while (currentHeadNode != null) {
+                newHeadNode = currentHeadNode.next;
+                if (head.compareAndSet(currentHeadNode, newHeadNode)) {
+                    break;
+                } else {
+                    LockSupport.parkNanos(1);
+                    currentHeadNode = head.get();
+                }
+            }
+            counter.incrementAndGet();
+            return currentHeadNode != null ? currentHeadNode.value : null;
+        }
+
+        public int getCounter() {
+            return counter.get();
+        }
+    }
+
+    public static class StandardStack<T> {
+        private StackNode<T> head;
+        private int counter = 0;
+
+        public synchronized void push(T value) {
+            StackNode<T> newHead = new StackNode<>(value);
+            newHead.next = head;
+            head = newHead;
+            counter++;
+        }
+
+        public synchronized T pop() {
+            if (head == null) {
+                counter++;
+                return null;
+            }
+
+            T value = head.value;
+            head = head.next;
+            counter++;
+            return value;
+        }
+
+        public int getCounter() {
+            return counter;
+        }
+    }
+
+    private static class StackNode<T> {
+        public T value;
+        public StackNode<T> next;
+
+        public StackNode(T value) {
+            this.value = value;
+            this.next = next;
+        }
+    }
+}

Java_Multithreading_Concurrency/Michael Pogrebinsky/JdMultiThreadPerformance/src/main/java/com/jd/thread/LockFree/AtomicIntEx.java

@@ -0,0 +1,67 @@
+package com.jd.thread.LockFree;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class AtomicIntEx {
+    public static void main(String[] args) throws InterruptedException {
+        InventoryCounter inventoryCounter = new InventoryCounter();
+        IncrementingThread incrementingThread = new IncrementingThread(inventoryCounter);
+        DecrementingThread decrementingThread = new DecrementingThread(inventoryCounter);
+
+        incrementingThread.start();
+        decrementingThread.start();
+
+        incrementingThread.join();
+        decrementingThread.join();
+
+        System.out.println("We currently have " + inventoryCounter.getItems() + " items");
+    }
+
+    public static class DecrementingThread extends Thread {
+
+        private InventoryCounter inventoryCounter;
+
+        public DecrementingThread(InventoryCounter inventoryCounter) {
+            this.inventoryCounter = inventoryCounter;
+        }
+
+        @Override
+        public void run() {
+            for (int i = 0; i < 10000; i++) {
+                inventoryCounter.decrement();
+            }
+        }
+    }
+
+    public static class IncrementingThread extends Thread {
+
+        private InventoryCounter inventoryCounter;
+
+        public IncrementingThread(InventoryCounter inventoryCounter) {
+            this.inventoryCounter = inventoryCounter;
+        }
+
+        @Override
+        public void run() {
+            for (int i = 0; i < 10000; i++) {
+                inventoryCounter.increment();
+            }
+        }
+    }
+
+    private static class InventoryCounter {
+        private AtomicInteger items = new AtomicInteger(0);
+
+        public void increment() {
+            items.incrementAndGet();
+        }
+
+        public void decrement() {
+            items.decrementAndGet();
+        }
+
+        public int getItems() {
+            return items.get();
+        }
+    }
+}