Merge remote-tracking branch 'origin/master'

Author: lokeshgupta1981

src/main/java/com/howtodoinjava/concurrency/BlockingThreadPoolExecutor.java

@@ -0,0 +1,51 @@
+package com.howtodoinjava.concurrency;
+
+import java.util.concurrent.*;
+
+public class BlockingThreadPoolExecutor extends ThreadPoolExecutor {
+    private final Semaphore semaphore;
+
+    public BlockingThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime,
+                                      TimeUnit unit, BlockingQueue<Runnable> workQueue) {
+        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
+        semaphore = new Semaphore(maximumPoolSize);
+    }
+
+    @Override
+    protected void beforeExecute(Thread t, Runnable r) {
+        super.beforeExecute(t, r);
+    }
+
+
+    @Override
+    public void execute(final Runnable task) {
+        
+        boolean acquired = false;
+
+        do {
+            try {
+                semaphore.acquire();
+                acquired = true;
+            } catch (final InterruptedException e) {
+                e.printStackTrace();
+            }
+        } while (!acquired);
+
+        try {
+            super.execute(task);
+        } catch (final RejectedExecutionException e) {
+            System.out.println("Task Rejected");
+            semaphore.release();
+            return;
+        }
+        semaphore.release();
+    }
+
+    @Override
+    protected void afterExecute(Runnable r, Throwable t) {
+        super.afterExecute(r, t);
+        if (t != null) {
+            t.printStackTrace();
+        }
+    }
+}

src/main/java/com/howtodoinjava/concurrency/BlockingThreadPoolExecutorDemo.java

@@ -0,0 +1,27 @@
+package com.howtodoinjava.concurrency;
+
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.TimeUnit;
+
+public class BlockingThreadPoolExecutorDemo {
+    public static void main(String[] args) throws InterruptedException {
+        BlockingQueue<Runnable> blockingQueue = new ArrayBlockingQueue<>(1);
+        BlockingThreadPoolExecutor executor = new BlockingThreadPoolExecutor(1, 1, 5000, TimeUnit.MILLISECONDS, blockingQueue);
+        executor.setRejectedExecutionHandler(new CustomRejectedExecutionHandler());
+
+        executor.prestartAllCoreThreads();
+
+        int threadCounter = 0;
+        while (true) {
+            threadCounter++;
+            // Adding threads one by one
+            System.out.println("Adding DemoTask : " + threadCounter);
+            blockingQueue.offer(new DemoTask(Integer.toString(threadCounter)));
+            if (threadCounter == 100)
+                break;
+        }
+
+        Thread.sleep(1000000);
+    }
+}

src/main/java/com/howtodoinjava/concurrency/CustomRejectedExecutionHandler.java

@@ -0,0 +1,18 @@
+package com.howtodoinjava.concurrency;
+
+import java.util.concurrent.RejectedExecutionHandler;
+import java.util.concurrent.ThreadPoolExecutor;
+
+public class CustomRejectedExecutionHandler implements RejectedExecutionHandler {
+    @Override
+    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
+        try
+        {
+            Thread.sleep(1000);
+            System.out.println("Try again : " + ((DemoTask) r).getName());
+            executor.execute(r);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}

src/main/java/com/howtodoinjava/concurrency/DemoTask.java

@@ -13,11 +13,11 @@ public String getName() {
 
     @Override
     public void run() {
+        System.out.println("Executing : " + name);
         try {
-            Thread.sleep(500);
+            Thread.sleep(1000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
-        System.out.println("Executing : " + name);
     }
 }

src/main/java/com/howtodoinjava/core/collections/map/README.md

@@ -4,4 +4,5 @@
 * [Java WeakHashMap](https://howtodoinjava.com/java/collections/java-weakhashmap/)
 * [Java IdentityHashMap](https://howtodoinjava.com/java/collections/java-identityhashmap/)
 * [Java Nested Map](https://howtodoinjava.com/java/collections/java-nested-map/)
-* [Java EnumMap](https://howtodoinjava.com/java/collections/java-enummap/)
+* [Java EnumMap](https://howtodoinjava.com/java/collections/java-enummap/)
+* [Java SubMap](https://howtodoinjava.com/java/collections/java-submap/)

src/main/java/com/howtodoinjava/core/collections/map/SubMaps.java

@@ -0,0 +1,67 @@
+package com.howtodoinjava.core.collections.map;
+
+import com.google.common.base.Predicates;
+import com.google.common.collect.Maps;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class SubMaps {
+    public static void main(String[] args) {
+        //1
+        Map<String, String> map = new HashMap<>();
+        map.put("key1", "Value1");
+        map.put("key2", "Value2");
+        map.put("key3", "Value3");
+
+        List<String> keysToRetain = List.of("key1", "key2");
+        map.keySet().retainAll(keysToRetain);
+
+        System.out.println(map);    //{key1=Value1, key2=Value2}
+
+        //2
+        TreeMap<String, String> treeMap = new TreeMap<>();
+
+        treeMap.put("key1", "Value1");
+        treeMap.put("key2", "Value2");
+        treeMap.put("key3", "Value3");
+
+        SortedMap<String, String> subMap = treeMap.subMap("key2", "key3");
+        SortedMap<String, String> headMap = treeMap.headMap("key2");
+        SortedMap<String, String> tailMap = treeMap.tailMap("key2");
+
+        System.out.println(subMap);
+        System.out.println(headMap);
+        System.out.println(tailMap);
+
+        subMap.put("key2", "NEW_VALUE_2");
+
+        System.out.println(subMap);     //{key2=NEW_VALUE_2}
+        System.out.println(treeMap);    //{key1=Value1, key2=NEW_VALUE_2, key3=Value3}
+
+        treeMap.put("key4", "value4");
+
+        System.out.println(tailMap);     //{key2=NEW_VALUE_2, key3=Value3, key4=value4}
+        System.out.println(treeMap);    //{key1=Value1, key2=NEW_VALUE_2, key3=Value3, key4=value4}
+
+        //3
+        Map<Integer, String> hashmap = new HashMap<>();
+        hashmap.put(1, "Value1");
+        hashmap.put(2, "Value2");
+        hashmap.put(3, "Value3");
+
+        List<Integer> keysList = Arrays.asList(1, 2);
+
+        Map<Integer, String> subHashmap = hashmap.entrySet()
+                .stream()
+                .filter(x -> keysList.contains(x.getKey()))
+                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+
+        System.out.println(subHashmap);     //{1=Value1, 2=Value2}
+        System.out.println(hashmap);
+
+        //4
+        Map<Integer, String> subMap1 = Maps.filterKeys(hashmap, Predicates.in(keysList));
+        System.out.print(subMap1);
+    }
+}