lamda streams threading

Author: Dhananjay Nagargoje

Diff for: .idea/workspace.xml

@@ -0,0 +1,100 @@
+package javarecipies.concurrency.creatingthreads;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.stream.IntStream;
+
+public class OneSynchronizedUse {
+
+     static Object lock = new Object();
+     static Lock reentrantLock = new ReentrantLock();
+    static class Counter {
+        private int count ;
+
+        public  void inc() {
+            count++;
+        }
+
+        public synchronized void inc1() {
+            count++;
+        }
+
+        public  void inc2() {
+            synchronized (lock) {
+                count++;
+                lock.notifyAll();
+            }
+        }
+
+        public synchronized void inc3() {
+            reentrantLock.lock();
+            count++;
+            reentrantLock.unlock();
+        }
+
+        public int getCount() {
+            return count;
+        }
+    }
+
+    public static void process() {
+
+        Counter c = new Counter();
+
+        Thread t1 = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                for (int i = 0; i < 99; i++) c.inc();
+            }
+        });
+
+
+        Thread t2 = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                for (int i = 0; i < 98; i++) c.inc();
+            }
+        });
+
+
+        Thread t3 = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                for (int i = 0; i < 97; i++) c.inc();
+            }
+        });
+
+        t1.start();
+        t2.start();
+        t3.start();
+
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        ExecutorService service = Executors.newFixedThreadPool(5);
+        Counter summation = new Counter();
+
+        IntStream.range(0, 963)
+                .forEach(count -> service.submit(summation::inc));
+        try {
+            service.awaitTermination(1000, TimeUnit.MILLISECONDS);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        System.out.println("Final Counter Value : " + summation.getCount());
+    }
+
+    public static void main(String[] args) {
+
+        process();
+
+    }
+}

Diff for: out/production/main/javarecipies/concurrency/creatingthreads/OneSynchronizedUse$1.class

@@ -0,0 +1,23 @@
+package javarecipies.java8;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.BinaryOperator;
+
+public class MyReducer {
+    static <T> T reduce(List<T> values, T identity, BinaryOperator<T> binaryOperator) {
+        T result = identity;
+        for (T value : values) {
+            result = binaryOperator.apply(result, value);
+        }
+        return result;
+    }
+
+    public static void main(String[] args) {
+        BinaryOperator<Integer> adder = (integer, integer2) -> integer + integer2;
+        List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
+
+        System.out.println(reduce(integers, 0, adder));
+
+    }
+}

Diff for: out/production/main/javarecipies/concurrency/creatingthreads/OneSynchronizedUse$2.class

@@ -0,0 +1,42 @@
+package javarecipies.java8;
+
+import java.util.*;
+import java.util.function.Consumer;
+
+public class NewCollectionMethods {
+
+     public static void main(String[] args) {
+         Map<Integer, ArrayList<Integer>> map1 = new HashMap<>();
+         Map<Integer, ArrayList<Integer>> map2 = new HashMap<>();
+         ArrayList<Integer> l1 = new ArrayList<>();
+         ArrayList<Integer> l2 = new ArrayList<>();
+         l1.add(1);
+         l1.add(2);
+         l1.add(3);
+
+         l2.add(4);
+         l2.add(5);
+         l2.add(6);
+
+         map1.putIfAbsent(1, l1);
+         map2.putIfAbsent(1, l2);
+
+         Consumer<Object> cout = System.out::println;
+         cout.accept(map1);
+         cout.accept(map2);
+
+         cout.accept("Merging map2 into map1");
+
+         map2.forEach((key2, val2) -> {
+             map1.merge(key2, val2, (oldval, newvalue) -> {
+                 oldval.addAll(newvalue);
+                 return oldval;
+             });
+         });
+
+         cout.accept(map1);
+
+
+     }
+
+}

Diff for: out/production/main/javarecipies/concurrency/creatingthreads/OneSynchronizedUse$3.class

@@ -27,10 +27,6 @@ public static void main(String[] args) {
         Predicate<Integer> isGreaterThan10 = x-> x>10;
         printer.accept(isGreaterThan10.test(9));
 
-
-
-
-
     }
 
 }

Diff for: out/production/main/javarecipies/concurrency/creatingthreads/OneSynchronizedUse$Counter.class

@@ -0,0 +1,22 @@
+package javarecipies.java8;
+
+import edu.princeton.cs.algs4.In;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class StreamsAnatomy {
+    public static void main(String[] args) {
+        List<Integer> profits = Arrays.asList(4,5,2,6,4,7,8,3,45,6,345,3324,576,2342,33);
+
+        //find first three max profits
+        List<Integer> maxThree = profits.stream()//stream source is collection
+                                    .sorted(Comparator.reverseOrder()) //intermidiate stateful operation
+                                    .limit(3)
+                                    .collect(Collectors.toList()); //termainal operation
+
+        System.out.println(maxThree);
+    }
+}