Readme

Rajeev Kumar Singh · Rajeev Kumar Singh · commit b855c63a0801 · 2017-07-29T10:09:10.000+05:30
diff --git a/README.md b/README.md
@@ -1,6 +1,6 @@
 # Java Concurrency/Multithreading Examples
 
-## Releavant Tutorials
+## Relevant Tutorials
 
 1. [Java Concurrency / Multithreading Basics](https://www.callicoder.com/java-concurrency-multithreading-basics/)
 
@@ -10,4 +10,6 @@
 
 4. [Java Callable and Future Tutorial](https://www.callicoder.com/java-callable-and-future-tutorial/)
 
-5. [Java Concurrency issues and Synchronization](https://www.callicoder.com/java-concurrency-issues-and-thread-synchronization/)
+5. [Java Concurrency issues and Synchronization](https://www.callicoder.com/java-concurrency-issues-and-thread-synchronization/)
+
+6. [Java Locks and Atomic Variables](https://www.callicoder.com/java-locks-and-atomic-variables-tutorial/)
diff --git a/java-lock-objects-and-atomic-variables/src/AtomicIntegerExample.java b/java-lock-objects-and-atomic-variables/src/AtomicIntegerExample.java
@@ -0,0 +1,36 @@
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Created by rajeevkumarsingh on 24/07/17.
+ */
+
+class AtomicCounter {
+    private AtomicInteger count = new AtomicInteger(0);
+
+    public int incrementAndGet() {
+        return count.incrementAndGet();
+    }
+
+    public int getCount() {
+        return count.get();
+    }
+}
+public class AtomicIntegerExample {
+    public static void main(String[] args) throws InterruptedException {
+        ExecutorService executorService = Executors.newFixedThreadPool(2);
+
+        AtomicCounter atomicCounter = new AtomicCounter();
+
+        for(int i = 0; i < 1000; i++) {
+            executorService.submit(() -> atomicCounter.incrementAndGet());
+        }
+
+        System.out.println("Final Count is : " + atomicCounter.getCount());
+
+        executorService.shutdown();
+        executorService.awaitTermination(60, TimeUnit.SECONDS);
+    }
+}
diff --git a/java-lock-objects-and-atomic-variables/src/ReadWriteLockExample.java b/java-lock-objects-and-atomic-variables/src/ReadWriteLockExample.java
@@ -56,5 +56,7 @@ public static void main(String[] args) {
 
         executorService.submit(readTask);
         executorService.submit(readTask);
+
+        executorService.shutdown();
     }
 }
diff --git a/java-lock-objects-and-atomic-variables/src/ReentrantLockExample.java b/java-lock-objects-and-atomic-variables/src/ReentrantLockExample.java
@@ -45,5 +45,6 @@ public static void main(String[] args) throws InterruptedException {
         executorService.awaitTermination(60, TimeUnit.SECONDS);
 
         System.out.println("Final count is : " + counter.getCount());
+
     }
 }
diff --git a/java-lock-objects-and-atomic-variables/src/ReentrantLockMethodsExample.java b/java-lock-objects-and-atomic-variables/src/ReentrantLockMethodsExample.java
@@ -0,0 +1,61 @@
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.ReentrantLock;
+
+class ReentrantLockCounterIncrement {
+    private final ReentrantLock lock = new ReentrantLock();
+
+    private int count = 0;
+
+    public int incrementAndGet() {
+        // Check if lock is currently acquired by any thread
+        System.out.println("IsLocked : " + lock.isLocked());
+
+        // Check if lock is acquired by the current thread itself.
+        System.out.println("IsHeldByCurrentThread : " + lock.isHeldByCurrentThread());
+
+        // Try to acquire the lock
+        boolean isAcquired;
+        try {
+            isAcquired = lock.tryLock(1, TimeUnit.SECONDS);
+            System.out.println("Lock Acquired : " + isAcquired + "\n");
+        } catch (InterruptedException e) {
+            throw new IllegalStateException(e);
+        }
+
+        if(isAcquired) {
+            try {
+                Thread.sleep(2000);
+                count = count + 1;
+            } catch (InterruptedException e) {
+                throw new IllegalStateException(e);
+            } finally {
+                lock.unlock();
+            }
+        }
+        return count;
+    }
+}
+
+public class ReentrantLockMethodsExample {
+
+    public static void main(String[] args) {
+        ExecutorService executorService = Executors.newFixedThreadPool(2);
+
+        ReentrantLockCounterIncrement lockCounterIncrement = new ReentrantLockCounterIncrement();
+
+        executorService.submit(() -> {
+           System.out.println("IncrementCount (First Thread) : " +
+                   lockCounterIncrement.incrementAndGet() + "\n");
+        });
+
+        executorService.submit(() -> {
+            System.out.println("IncrementCount (Second Thread) : " +
+                    lockCounterIncrement.incrementAndGet() + "\n");
+        });
+
+        executorService.shutdown();
+
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -56,5 +56,7 @@ public static void main(String[] args) {`
`56`	`56`
`57`	`57`	`executorService.submit(readTask);`
`58`	`58`	`executorService.submit(readTask);`
	`59`	`+`
	`60`	`+ executorService.shutdown();`
`59`	`61`	`}`
`60`	`62`	`}`
Original file line number	Diff line number	Diff line change
`@@ -45,5 +45,6 @@ public static void main(String[] args) throws InterruptedException {`
`45`	`45`	`executorService.awaitTermination(60, TimeUnit.SECONDS);`
`46`	`46`
`47`	`47`	`System.out.println("Final count is : " + counter.getCount());`
	`48`	`+`
`48`	`49`	`}`
`49`	`50`	`}`