*/
-import java.util.Random;
-import java.util.concurrent.locks.Lock;
-import java.util.concurrent.locks.ReentrantLock;
-
+@SuppressWarnings("InfiniteLoopStatement")
public class Runner {
private Account acc1 = new Account();
@@ -38,22 +45,16 @@ private void acquireLocks(Lock firstLock, Lock secondLock) throws InterruptedExc
gotFirstLock = firstLock.tryLock();
gotSecondLock = secondLock.tryLock();
} finally {
- if (gotFirstLock && gotSecondLock) {
- return;
- }
- if (gotFirstLock) {
- firstLock.unlock();
- }
- if (gotSecondLock) {
- secondLock.unlock();
- }
+ if (gotFirstLock && gotSecondLock) return;
+ else if (gotFirstLock) firstLock.unlock();
+ else if (gotSecondLock) secondLock.unlock();
}
// Locks not acquired
Thread.sleep(1);
}
}
- //firstThreaad runs
+ //firstThread runs
public void firstThread() throws InterruptedException {
Random random = new Random();
for (int i = 0; i < 10000; i++) {
diff --git a/JavaMultiThreadingCodes/src/Deadlock_11/SimpleDeadLock.java b/JavaMultiThreadingCodes/src/Deadlock_11/SimpleDeadLock.java
index 47f769a..9ad7f65 100644
--- a/JavaMultiThreadingCodes/src/Deadlock_11/SimpleDeadLock.java
+++ b/JavaMultiThreadingCodes/src/Deadlock_11/SimpleDeadLock.java
@@ -2,7 +2,9 @@
/**
* Source: http://www.herongyang.com/Java/Deadlock-What-Is-Deadlock.html
- * Deadlock is a programming situation where two or more threads are blocked
+ *
+ * Deadlock
+ * is a programming situation where two or more threads are blocked
* forever, this situation arises with at least two threads and two or more
* resources.
*
@@ -10,8 +12,8 @@
*/
public class SimpleDeadLock {
- public static Object lock1 = new Object();
- public static Object lock2 = new Object();
+ public static final Object lock1 = new Object();
+ public static final Object lock2 = new Object();
private int index;
public static void main(String[] a) {
@@ -28,8 +30,7 @@ public void run() {
System.out.println("Thread 1: Holding lock 1...");
try {
Thread.sleep(10);
- } catch (InterruptedException e) {
- }
+ } catch (InterruptedException ignored) {}
System.out.println("Thread 1: Waiting for lock 2...");
synchronized (lock2) {
System.out.println("Thread 2: Holding lock 1 & 2...");
@@ -45,8 +46,7 @@ public void run() {
System.out.println("Thread 2: Holding lock 2...");
try {
Thread.sleep(10);
- } catch (InterruptedException e) {
- }
+ } catch (InterruptedException ignored) {}
System.out.println("Thread 2: Waiting for lock 1...");
synchronized (lock1) {
System.out.println("Thread 2: Holding lock 2 & 1...");
diff --git a/JavaMultiThreadingCodes/src/InterruptingThreads14/App.java b/JavaMultiThreadingCodes/src/InterruptingThreads14/App.java
index f36769c..a843f1e 100644
--- a/JavaMultiThreadingCodes/src/InterruptingThreads14/App.java
+++ b/JavaMultiThreadingCodes/src/InterruptingThreads14/App.java
@@ -1,27 +1,31 @@
package InterruptingThreads14;
-import java.util.Random;
-import java.util.concurrent.Callable;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
-import java.util.concurrent.TimeUnit;
+import java.util.concurrent.*;
/**
- * how to interrupt running threads in Java using the built-in thread
- * interruption mechanism.
- *
- * Source:http://www.javamex.com/tutorials/threads/thread_interruption.shtml
- * Incidentally, it is important not to confuse thread interruption with either
+ * How to interrupt running threads in Java using the built-in thread
+ * interruption mechanism.
+ *
+ * Source:
+ *
+ * http://www.javamex.com/tutorials/threads/thread_interruption.shtml
+ *
+ * Incidentally, it is important NOT to confuse thread interruption with either
* software interrupts (where the CPU automatically interrupts the current
* instruction flow in order to call a registered piece of code periodically— as
* in fact happens to drive the thread scheduler) and hardware interrupts (where
* the CPU automatically performs a similar task in response to some hardware
* signal).
- *
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ *
+ * Codes with minor comments are from
+ *
+ * http://www.caveofprogramming.com/youtube/
+ *
+ *
* also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
+ * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
*
* @author Z.B. Celik
*/
@@ -31,29 +35,39 @@ public static void main(String[] args) throws InterruptedException {
System.out.println("Starting.");
- ExecutorService executer = Executors.newCachedThreadPool();
+ ExecutorService executor = Executors.newCachedThreadPool();
- Future fu = executer.submit(new Callable() {
+ Future fu = executor.submit(new Callable() {
@Override
public Void call() throws Exception {
- Random ran = new Random();
+
for (int i = 0; i < 1E8; i++) {
if (Thread.currentThread().isInterrupted()) {
- System.out.println("Interrupted!");
+ System.out.printf("Interrupted at %d !!!", i);
break;
}
- Math.sin(ran.nextDouble());
}
+
return null;
}
});
- executer.shutdown();
+ executor.shutdown();
Thread.sleep(500);
- executer.shutdownNow();
- executer.awaitTermination(1, TimeUnit.DAYS);
+ /*
+ in this example, there are different ways you can interrupt a thread
+ execution.
+ */
+
+ //JavaDoc: http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Future.html#cancel-boolean-
+// fu.cancel(true);
+
+ //JavaDoc: http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html#shutdownNow--
+ executor.shutdownNow();
+
+ executor.awaitTermination(1, TimeUnit.DAYS);
System.out.println("Finished.");
}
diff --git a/JavaMultiThreadingCodes/src/JoiningAndSynchronizeThreads_3/Worker.java b/JavaMultiThreadingCodes/src/JoiningAndSynchronizeThreads_3/Worker.java
index d2bb0c3..e89df8a 100644
--- a/JavaMultiThreadingCodes/src/JoiningAndSynchronizeThreads_3/Worker.java
+++ b/JavaMultiThreadingCodes/src/JoiningAndSynchronizeThreads_3/Worker.java
@@ -4,12 +4,18 @@
import java.util.logging.Logger;
/**
- * synchronized ("only let one thread in here at a time".) and join ("wait until
+ * {@code synchronized} ("only let one thread in here at a time".) and {@code join} ("wait until
* thread on which join has called finished") keyword.
- *
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ *
+ * Codes with minor comments are from
+ *
+ * http://www.caveofprogramming.com/youtube/
+ *
+ *
* also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
+ * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
*
* @author Z.B. Celik
*/
@@ -70,10 +76,7 @@ public void run() {
try {
thread1.join();
thread2.join();
- } catch (InterruptedException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
+ } catch (InterruptedException ignored) {}
System.out.println("Count is: " + count);
}
}
diff --git a/JavaMultiThreadingCodes/src/LockObjects_4/App.java b/JavaMultiThreadingCodes/src/LockObjects_4/App.java
index 96b6a13..c7941fb 100644
--- a/JavaMultiThreadingCodes/src/LockObjects_4/App.java
+++ b/JavaMultiThreadingCodes/src/LockObjects_4/App.java
@@ -1,9 +1,15 @@
package LockObjects_4;
/**
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ * Codes with minor comments are from
+ *
+ * http://www.caveofprogramming.com/youtube/
+ *
+ *
* also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
+ * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
*
* @author Z.B. Celik
*/
diff --git a/JavaMultiThreadingCodes/src/LockObjects_4/Worker.java b/JavaMultiThreadingCodes/src/LockObjects_4/Worker.java
index ae381bb..70ad012 100644
--- a/JavaMultiThreadingCodes/src/LockObjects_4/Worker.java
+++ b/JavaMultiThreadingCodes/src/LockObjects_4/Worker.java
@@ -10,10 +10,16 @@
* making the method synchronized or making an object inside the method
* synchronized, By defining two different locks we say that one thread may
* execute the stageOne while other executes stageTwo.
- *
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ *
+ * Codes with minor comments are from
+ *
+ * http://www.caveofprogramming.com/youtube/
+ *
+ *
* also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
+ * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
*
* @author Z.B. Celik
*/
@@ -21,11 +27,11 @@ public class Worker {
private Random random = new Random();
- private Object lock1 = new Object();
- private Object lock2 = new Object();
+ private final Object lock1 = new Object();
+ private final Object lock2 = new Object();
- private List list1 = new ArrayList();
- private List list2 = new ArrayList();
+ private List list1 = new ArrayList<>();
+ private List list2 = new ArrayList<>();
public void stageOne() {
diff --git a/JavaMultiThreadingCodes/src/LockObjects_4/WorkerMethodsSynchronized.java b/JavaMultiThreadingCodes/src/LockObjects_4/WorkerMethodsSynchronized.java
index 5b7ac30..c01b492 100644
--- a/JavaMultiThreadingCodes/src/LockObjects_4/WorkerMethodsSynchronized.java
+++ b/JavaMultiThreadingCodes/src/LockObjects_4/WorkerMethodsSynchronized.java
@@ -10,10 +10,16 @@
* making the method synchronized or making "different" objects inside the
* method synchronized, By defining two different locks we say that one thread
* may execute the stageOne while other executes stageTwo.
- *
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ *
+ * Codes with minor comments are from
+ *
+ * http://www.caveofprogramming.com/youtube/
+ *
+ *
* also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
+ * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
*
* @author Z.B. Celik
*/
@@ -21,8 +27,8 @@ public class WorkerMethodsSynchronized {
private Random random = new Random();
- private List list1 = new ArrayList();
- private List list2 = new ArrayList();
+ private List list1 = new ArrayList<>();
+ private List list2 = new ArrayList<>();
/**
* synchronized, methods use different data (list1 list2) so by synchronized
@@ -78,10 +84,7 @@ public void run() {
try {
t1.join();
t2.join();
- } catch (InterruptedException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
+ } catch (InterruptedException ignored) {}
long end = System.currentTimeMillis();
diff --git a/JavaMultiThreadingCodes/src/LowLevelProducerConsumer_9/App.java b/JavaMultiThreadingCodes/src/LowLevelProducerConsumer_9/App.java
index 99eb416..aabbfd3 100644
--- a/JavaMultiThreadingCodes/src/LowLevelProducerConsumer_9/App.java
+++ b/JavaMultiThreadingCodes/src/LowLevelProducerConsumer_9/App.java
@@ -1,15 +1,22 @@
package LowLevelProducerConsumer_9;
/**
- * How to implement the producer-consumer pattern using "low level" techniques;
+ * How to implement the Producer-Consumer pattern using "low level" techniques;
* namely, wait, notify and synchronized. This isn't the best way to implement a
- * producer-consumer pattern in Java (see tutorial 7 use of BlockingQueue for
+ * Producer-Consumer pattern in Java
+ * (see tutorial 7 use of {@link java.util.concurrent.BlockingQueue} for
* the best way); but this tutorial will help you to understand how to use wait
* and notify.
- *
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ *
+ * Codes with minor comments are from
+ *
+ * http://www.caveofprogramming.com/youtube/
+ *
+ *
* also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
+ * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
*
* @author Z.B. Celik
*/
@@ -22,9 +29,7 @@ public static void main(String[] args) throws InterruptedException {
public void run() {
try {
processor.produce();
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
+ } catch (InterruptedException ignored) {}
}
});
@@ -33,14 +38,18 @@ public void run() {
public void run() {
try {
processor.consume();
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
+ } catch (InterruptedException ignored) {}
}
});
+
t1.start();
t2.start();
- t1.join();
- t2.join();
+// t1.join();
+// t2.join();
+
+ // Pause for 30 seconds and force quitting the app (because we're
+ // looping infinitely)
+ Thread.sleep(30000);
+ System.exit(0);
}
}
diff --git a/JavaMultiThreadingCodes/src/LowLevelProducerConsumer_9/Processor.java b/JavaMultiThreadingCodes/src/LowLevelProducerConsumer_9/Processor.java
index a93ba04..e061c1d 100644
--- a/JavaMultiThreadingCodes/src/LowLevelProducerConsumer_9/Processor.java
+++ b/JavaMultiThreadingCodes/src/LowLevelProducerConsumer_9/Processor.java
@@ -1,26 +1,33 @@
package LowLevelProducerConsumer_9;
+import java.util.LinkedList;
+import java.util.Random;
+
/**
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ * Codes with minor comments are from
+ *
+ * http://www.caveofprogramming.com/youtube/
+ *
+ *
* also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
+ * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
*
* @author Z.B. Celik
*/
-import java.util.LinkedList;
-import java.util.Random;
-
+@SuppressWarnings("InfiniteLoopStatement")
public class Processor {
private LinkedList list = new LinkedList<>();
private final int LIMIT = 10;
- private Object lock = new Object();
+ private final Object lock = new Object();
public void produce() throws InterruptedException {
int value = 0;
while (true) {
synchronized (lock) {
- //whenever the threade is notofied starts again from the loop
+ //whenever the thread is notified starts again from the loop
while (list.size() == LIMIT) {
lock.wait();// wait() is also true
}
diff --git a/JavaMultiThreadingCodes/src/ProducerConsumer_7/App.java b/JavaMultiThreadingCodes/src/ProducerConsumer_7/App.java
index 7440082..b064da4 100644
--- a/JavaMultiThreadingCodes/src/ProducerConsumer_7/App.java
+++ b/JavaMultiThreadingCodes/src/ProducerConsumer_7/App.java
@@ -1,14 +1,22 @@
package ProducerConsumer_7;
/**
- * producer-consumer pattern in Java using the ArrayBlockingQueue Java class.
+ * Producer-Consumer pattern in Java using the {@link java.util.concurrent
+ * .ArrayBlockingQueue} Java class.
+ *
* Producer-Consumer is the situation where one or more threads are producing
* data items and adding them to a shared data store of some kind while one or
* more other threads process those items, removing them from the data store.
- *
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ *
+ * Codes with minor comments are from
+ *
+ * http://www.caveofprogramming.com/youtube/
+ *
+ *
* also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
+ * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
*
* @author Z.B. Celik
*/
@@ -16,32 +24,31 @@
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
+@SuppressWarnings("InfiniteLoopStatement")
public class App {
/**
- * Thread safe implementation of Queue data structure so you do not need to
- * worry about synchronization. More specifically BlockingQueue
+ * Thread safe implementation of {@link java.util.Queue} data structure so
+ * you do not need to worry about synchronization.
+ * More specifically {@link java.util.concurrent.BlockingQueue}
* implementations are thread-safe. All queuing methods are atomic in nature
* and use internal locks or other forms of concurrency control. If
* BlockingQueue is not used queue is shared data structure either
- * sychronized or wait() notify() (see Course 8) should be used. Java 1.5
- * introduced a new concurrency library (in the java.util.concurrent
- * package) which was designed to provide a higher level abstraction over
+ * {@code synchronized} or {@code wait() notify()} (see Course 8) should be
+ * used.
+ * Java 1.5 introduced a new concurrency library {@link java.util.concurrent}
+ * which was designed to provide a higher level abstraction over
* the wait/notify mechanism.
*/
private static BlockingQueue queue = new ArrayBlockingQueue<>(10);
public static void main(String[] args) throws InterruptedException {
- /**
- *
- */
+
Thread t1 = new Thread(new Runnable() {
public void run() {
try {
producer();
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
+ } catch (InterruptedException ignored) {}
}
});
@@ -49,16 +56,18 @@ public void run() {
public void run() {
try {
consumer();
- } catch (InterruptedException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
+ } catch (InterruptedException ignored) {}
}
});
t1.start();
t2.start();
- t1.join();
- t2.join();
+// t1.join();
+// t2.join();
+
+ // Pause for 30 seconds and force quitting the app (because we're
+ // looping infinitely)
+ Thread.sleep(30000);
+ System.exit(0);
}
private static void producer() throws InterruptedException {
@@ -71,7 +80,7 @@ private static void producer() throws InterruptedException {
private static void consumer() throws InterruptedException {
Random random = new Random();
while (true) {
- //Thread.sleep(100);
+ Thread.sleep(100);
if (random.nextInt(10) == 0) {
Integer value = queue.take();//if queue is empty waits
System.out.println("Taken value: " + value + "; Queue size is: " + queue.size());
diff --git a/JavaMultiThreadingCodes/src/ReentrantLocks_10/App.java b/JavaMultiThreadingCodes/src/ReentrantLocks_10/App.java
index 96a43b8..845fbe7 100644
--- a/JavaMultiThreadingCodes/src/ReentrantLocks_10/App.java
+++ b/JavaMultiThreadingCodes/src/ReentrantLocks_10/App.java
@@ -1,36 +1,68 @@
package ReentrantLocks_10;
/**
- * the ReentrantLock class in Java as an alternative to synchronized code
- * blocks. ReentrantLocks let you do all the stuff that you can do with
- * synchronized, wait and notify, plus some more stuff besides that may come in
+ * the {@link java.util.concurrent.locks.ReentrantLock} class in Java as an
+ * alternative to synchronized code blocks.
+ *
+ * {@link java.util.concurrent.locks.ReentrantLock}s let you do all the
+ * stuff that you can do with {@code synchronized}, {@link Object#wait()} and
+ * {@link Object#notify()}, plus some more stuff. Besides that may come in
* handy from time to time.
- *
- * Source:
+ *
+ * Source:
* http://docs.oracle.com/javase/1.5.0/docs/api/java/util/concurrent/locks/ReentrantLock.html
- *
- * ReentrantLock Extended capabilities include:
- *
- * The ability to have more than one condition variable per monitor. Monitors
- * that use the synchronized keyword can only have one. This means reentrant
- * locks support more than one wait()/notify() queue. The ability to make the
- * lock "fair". "[fair] locks favor granting access to the longest-waiting
+ *
+ *
+ * {@link java.util.concurrent.locks.ReentrantLock} Extended capabilities
+ * include:
+ *
+ *
+ * -
+ * The ability to have more than one {@link java.util.concurrent.locks.Condition}
+ * variable per monitor.
+ *
+ * - Monitors that use the synchronized keyword can only have one. This means
+ * {@link java.util.concurrent.locks.ReentrantLock}s support more than one
+ * {@link Object#wait()}/{@link Object#notify()} queue.
+ *
+ * -
+ * The ability to make the lock "fair".
+ *
+ * "[fair] locks favor granting access to the longest-waiting
* thread. Otherwise this lock does not guarantee any particular access order."
- * Synchronized blocks are unfair. The ability to check if the lock is being
- * held. The ability to get the list of threads waiting on the lock.
- *
- * The disadvantages of reentrant locks are:
- *
- * Need to add import statement. Need to wrap lock acquisitions in a try/finally
- * block. This makes it more ugly than the synchronized keyword. The
- * synchronized keyword can be put in method definitions which avoids the need
- * for a block which reduces nesting. For more complete comparison of
- * reentrantLocks and synchronized see
+ *
+ *
+ * - Synchronized blocks are unfair.
+ * - The ability to check if the lock is being
+ * held.
+ * - The ability to get the list of threads waiting on the lock.
+ *
+ *
+ * The disadvantages of {@link java.util.concurrent.locks.ReentrantLock}s are:
+ *
+ *
+ * - Need to add import statement.
+ * - Need to wrap lock acquisitions in a try/finally block. This makes it more
+ * ugly than the synchronized keyword.
+ * - The synchronized keyword can be put in method definitions which avoids
+ * the need for a block which reduces nesting.
+ *
+ *
+ * For more complete comparison of
+ * {@link java.util.concurrent.locks.ReentrantLock}s and {@code synchronized}
+ * see:
* http://guruzon.com/1/concurrency/explicit-lock-locking/difference-between-synchronized-and-reentrantlock-in-java
- *
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ *
+ *
+ * Codes with minor comments are from
+ *
+ * http://www.caveofprogramming.com/youtube/
+ *
+ *
* also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
+ * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
*
* @author Z.B. Celik
*/
@@ -42,8 +74,7 @@ public static void main(String[] args) throws Exception {
public void run() {
try {
runner.firstThread();
- } catch (InterruptedException e) {
- e.printStackTrace();
+ } catch (InterruptedException ignored) {
}
}
});
@@ -52,8 +83,7 @@ public void run() {
public void run() {
try {
runner.secondThread();
- } catch (InterruptedException e) {
- e.printStackTrace();
+ } catch (InterruptedException ignored) {
}
}
});
diff --git a/JavaMultiThreadingCodes/src/ReentrantLocks_10/Runner.java b/JavaMultiThreadingCodes/src/ReentrantLocks_10/Runner.java
index 018f5d6..b97b4af 100644
--- a/JavaMultiThreadingCodes/src/ReentrantLocks_10/Runner.java
+++ b/JavaMultiThreadingCodes/src/ReentrantLocks_10/Runner.java
@@ -1,36 +1,52 @@
package ReentrantLocks_10;
+import java.util.Scanner;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
/**
- * Source:http://www.journaldev.com/2377/java-lock-example-and-concurrency-lock-vs-synchronized
- *
- * Lock: This is the base interface for Lock API. It provides all the features
+ * Source:
+ * http://www.journaldev.com/2377/java-lock-example-and-concurrency-lock-vs-synchronized
+ *
+ * {@link java.util.concurrent.locks.Lock}:
+ * This is the base interface for Lock API. It provides all the features
* of synchronized keyword with additional ways to create different Conditions
* for locking, providing timeout for thread to wait for lock. Some of the
- * important methods are lock() to acquire the lock, unlock() to release the
- * lock, tryLock() to wait for lock for a certain period of time, newCondition()
+ * important methods are {@link java.util.concurrent.locks.Lock#lock()} to
+ * acquire the lock, {@link java.util.concurrent.locks.Lock#unlock()} to release
+ * the lock, {@link java.util.concurrent.locks.Lock#tryLock()} to wait for lock
+ * for a certain period of time,
+ * {@link java.util.concurrent.locks.Lock#newCondition()}
* to create the Condition etc.
- *
- * ReentrantLock: This is the most widely used implementation class of Lock
+ *
+ * {@link java.util.concurrent.locks.ReentrantLock}:
+ * This is the most widely used implementation class of Lock
* interface. This class implements the Lock interface in similar way as
* synchronized keyword. (see App.java for more)
- *
- * Condition: Condition objects are similar to Object wait-notify model with
+ *
+ * {@link java.util.concurrent.locks.Condition}:
+ * Condition objects are similar to Object wait-notify model with
* additional feature to create different sets of wait. A Condition object is
- * always created by Lock object. Some of the important methods are await() that
- * is similar to wait() and signal(), signalAll() that is similar to notify()
- * and notifyAll() methods.
- *
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ * always created by Lock object. Some of the important methods are
+ * {@link java.util.concurrent.locks.Condition#await()}
+ * that is similar to {@link Object#wait()}.
+ * {@link java.util.concurrent.locks.Condition#signal()} and
+ * {@link java.util.concurrent.locks.Condition#signalAll()}
+ * that are similar to
+ * {@link Object#notify()} and {@link Object#notifyAll()} methods.
+ *
+ * Codes with minor comments are from
+ *
+ * http://www.caveofprogramming.com/youtube/
+ *
+ *
* also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
+ * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
*
* @author Z.B. Celik
*/
-import java.util.Scanner;
-import java.util.concurrent.locks.Condition;
-import java.util.concurrent.locks.Lock;
-import java.util.concurrent.locks.ReentrantLock;
-
public class Runner {
private int count = 0;
@@ -65,7 +81,8 @@ public void secondThread() throws InterruptedException {
try {
increment();
} finally {
- lock.unlock();//should be written to unlock Thread whenever signal() is called
+ //should be written to unlock Thread whenever signal() is called
+ lock.unlock();
}
}
diff --git a/JavaMultiThreadingCodes/src/Semaphores_12/App.java b/JavaMultiThreadingCodes/src/Semaphores_12/App.java
index dcccb55..154da74 100644
--- a/JavaMultiThreadingCodes/src/Semaphores_12/App.java
+++ b/JavaMultiThreadingCodes/src/Semaphores_12/App.java
@@ -5,34 +5,45 @@
import java.util.concurrent.TimeUnit;
/**
- * Semaphores are mainly used to limit the number of simultaneous threads that
+ * {@link java.util.concurrent.Semaphore}s
+ * are mainly used to limit the number of simultaneous threads that
* can access a resources, but you can also use them to implement deadlock
* recovery systems since a semaphore with one permit is basically a lock that
- * you can unlock from other threads.
- *
+ * can unlock from other threads.
+ *
* Source:
+ *
* http://stackoverflow.com/questions/771347/what-is-mutex-and-semaphore-in-java-what-is-the-main-difference
- *
- * Mutex is basically mutual exclusion. Only one thread can acquire the resource
- * at once. When one thread acquires the resource, no other thread is allowed to
- * acquire the resource until the thread owning the resource releases. All
- * threads waiting for acquiring resource would be blocked.
- *
+ *
+ *
+ * Mutex (or a semaphore initialized to 1; meaning there's only one resource)
+ * is basically a mutual exclusion; Only one thread can acquire the resource
+ * at once, and all other threads trying to acquire the resource are blocked
+ * until the thread owning the resource releases.
+ *
* Semaphore is used to control the number of threads executing. There will be
* fixed set of resources. The resource count will gets decremented every time
* when a thread owns the same. When the semaphore count reaches 0 then no other
* threads are allowed to acquire the resource. The threads get blocked till
* other threads owning resource releases.
- *
+ *
+ *
* In short, the main difference is how many threads are allowed to acquire the
- * resource at once ?
- *
+ * resource at once.
+ * TODO -- go a little more in depth explaining that
* Mutex --its ONE. Semaphore -- its DEFINED_COUNT, ( as many as semaphore
* count)
- *
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ *
+ *
+ * Codes with minor comments are from
+ *
+ * http://www.caveofprogramming.com/youtube/
+ *
+ *
* also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
+ * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
*
* @author Z.B. Celik
*/
@@ -40,13 +51,15 @@ public class App {
public static void main(String[] args) throws Exception {
ExecutorService executor = Executors.newCachedThreadPool();
- for (int i = 0; i < 13; i++) { //200 hundred times will be calleds
+
+ for (int i = 0; i < 20; i++) { //200 hundred times will be called
executor.submit(new Runnable() {
public void run() {
- Connection.getInstance().connect();
+ Connectionn.getInstance().connect();
}
});
}
+
executor.shutdown();
executor.awaitTermination(1, TimeUnit.DAYS);
}
diff --git a/JavaMultiThreadingCodes/src/Semaphores_12/Connection.java b/JavaMultiThreadingCodes/src/Semaphores_12/Connection.java
index f8f22c8..88836e2 100644
--- a/JavaMultiThreadingCodes/src/Semaphores_12/Connection.java
+++ b/JavaMultiThreadingCodes/src/Semaphores_12/Connection.java
@@ -4,19 +4,38 @@
/**
* Semaphores
- *
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ *
+ * Codes with minor comments are from
+ *
+ * http://www.caveofprogramming.com/youtube/
+ *
+ *
* also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
+ * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
*
* @author Z.B. Celik
*/
public class Connection {
private static Connection instance = new Connection();
- //limit connections to 10
- //true means whichever the thread call the acquire first gets it first,
- //in queue placed firts to obtain the permit.
+/*
+ limit connections to 10
+ true means whichever thread gets first in the waiting pool (queue)
+ waiting to acquire a resource, is first to obtain the permit.
+
+ Note that I called it a pool!
+ The reason is when you say "Queue", you're saying that things are
+ scheduled to be FIFO (First In First Out) .. which is not always the case
+ here!
+ When you initialize the semaphore with Fairness, by setting its second
+ argument to true, it will treat the waiting threads like FIFO.
+ But,
+ it doesn't have to be that way if you don't set on the fairness. the JVM
+ may schedule the waiting threads in some other manner that it sees best
+ (See the Java specifications for that).
+*/
private Semaphore sem = new Semaphore(10, true);
private int connections = 0;
@@ -29,16 +48,18 @@ public static Connection getInstance() {
public void connect() {
try {
- sem.acquire(); // get permit decrease the sem value, if 0 wait for release
- } catch (InterruptedException e1) {
- e1.printStackTrace();
- }
- try {
- //if doConnect throws and exception is still releases the permit
- //so we use a separate method here to increase the connections count.
+
+ // get permit decrease the sem value, if 0 wait for release
+ sem.acquire();
+
+ //if doConnect throws and exception is still releases the permit
+ //so we use a separate method here to increase the connections count
doConnect();
+
+ } catch (InterruptedException ignored) {
} finally {
- sem.release();// release permit, increase the sem value and activate waiting thread
+ //release permit, increase the sem value and activate waiting thread
+ sem.release();
}
}
@@ -51,11 +72,9 @@ public void doConnect() {
//do your job
System.out.println("Working on connections " + Thread.currentThread().getName());
Thread.sleep(2000);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
+ } catch (InterruptedException ignored) {}
//when exit doConnect method decrement number of connections
- synchronized (this) {//atamoic
+ synchronized (this) {//atomic
connections--;
System.out.println("I'm done " + Thread.currentThread().getName() + " Connection is released , connection count: " + connections);
}
diff --git a/JavaMultiThreadingCodes/src/Semaphores_12/Connectionn.java b/JavaMultiThreadingCodes/src/Semaphores_12/Connectionn.java
new file mode 100644
index 0000000..0171cc7
--- /dev/null
+++ b/JavaMultiThreadingCodes/src/Semaphores_12/Connectionn.java
@@ -0,0 +1,73 @@
+package Semaphores_12;
+
+import java.util.concurrent.Semaphore;
+
+/**
+ * Semaphores
+ *
+ * Codes with minor comments are from
+ *
+ * http://www.caveofprogramming.com/youtube/
+ *
+ *
+ * also freely available at
+ *
+ * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
+ *
+ * @author Z.B. Celik
+ */
+public class Connectionn {
+
+ private static Connectionn instance = new Connectionn();
+ /*
+ limit connections to 10
+ true means whichever thread gets first in the waiting pool (queue)
+ waiting to acquire a resource, is first to obtain the permit.
+
+ Note that I called it a pool!
+ The reason is when you say "Queue", you're saying that things are
+ scheduled to be FIFO (First In First Out) .. which is not always the case
+ here!
+ When you initialize the semaphore with Fairness, by setting its second
+ argument to true, it will treat the waiting threads like FIFO.
+ But,
+ it doesn't have to be that way if you don't set on the fairness. the JVM
+ may schedule the waiting threads in some other manner that it sees best
+ (See the Java specifications for that).
+ */
+ private Semaphore sem = new Semaphore(10, true);
+
+ private Connectionn() {
+ }
+
+ public static Connectionn getInstance() {
+ return instance;
+ }
+
+ public void connect() {
+ try {
+
+ // get permit decrease the sem value, if 0 wait for release
+ sem.acquire();
+
+ System.out.printf("%s:: Current connections (max 10 allowed): %d\n",
+ Thread.currentThread().getName(),
+ sem.availablePermits());
+
+ //do your job
+ System.out.printf("%s:: WORKING...\n",
+ Thread.currentThread().getName());
+ Thread.sleep(2000);
+
+ System.out.printf("%s:: Connection released. Permits Left = %d\n",
+ Thread.currentThread().getName(),
+ sem.availablePermits());
+
+ } catch (InterruptedException ignored) {
+ } finally {
+ //release permit, increase the sem value and activate waiting thread
+ sem.release();
+ }
+ }
+}
diff --git a/JavaMultiThreadingCodes/src/StartingThreads_1/ApplicationAnonymous.java b/JavaMultiThreadingCodes/src/StartingThreads_1/ApplicationAnonymous.java
index cd99566..8e11f90 100644
--- a/JavaMultiThreadingCodes/src/StartingThreads_1/ApplicationAnonymous.java
+++ b/JavaMultiThreadingCodes/src/StartingThreads_1/ApplicationAnonymous.java
@@ -2,10 +2,16 @@
/**
* Starting threads using the Thread constructor with anonymous classes
- *
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ *
+ * Codes with minor comments are from
+ *
+ * http://www.caveofprogramming.com/youtube/
+ *
+ *
* also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
+ * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
*
* @author Z.B. Celik
*/
@@ -20,10 +26,7 @@ public void run() {
try {
Thread.sleep(100);
- } catch (InterruptedException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
+ } catch (InterruptedException ignored) {}
}
}
});
diff --git a/JavaMultiThreadingCodes/src/StartingThreads_1/ApplicationExtends.java b/JavaMultiThreadingCodes/src/StartingThreads_1/ApplicationExtends.java
index fbbac2e..68d346a 100644
--- a/JavaMultiThreadingCodes/src/StartingThreads_1/ApplicationExtends.java
+++ b/JavaMultiThreadingCodes/src/StartingThreads_1/ApplicationExtends.java
@@ -2,10 +2,16 @@
/**
* Starting Threads with extends
- *
+ *
* Codes with minor comments are from
- * http://www.caveofprogramming.com/youtube/ also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
+ * http://www.caveofprogramming.com/youtube/
+ *
+ *
+ * also freely available at
+ *
+ * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
*
* @author Z.B. Celik
*/
diff --git a/JavaMultiThreadingCodes/src/StartingThreads_1/ApplicationRunnable.java b/JavaMultiThreadingCodes/src/StartingThreads_1/ApplicationRunnable.java
index 5d5237a..a7561e3 100644
--- a/JavaMultiThreadingCodes/src/StartingThreads_1/ApplicationRunnable.java
+++ b/JavaMultiThreadingCodes/src/StartingThreads_1/ApplicationRunnable.java
@@ -2,10 +2,16 @@
/**
* Starting Threads using Runnable Interface
- *
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ *
+ * Codes with minor comments are from
+ *
+ * http://www.caveofprogramming.com/youtube/
+ *
+ *
* also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
+ * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
*
* @author Z.B. Celik
*/
diff --git a/JavaMultiThreadingCodes/src/ThreadPools_5/App.java b/JavaMultiThreadingCodes/src/ThreadPools_5/App.java
index c94b1c6..3cc0c33 100644
--- a/JavaMultiThreadingCodes/src/ThreadPools_5/App.java
+++ b/JavaMultiThreadingCodes/src/ThreadPools_5/App.java
@@ -2,10 +2,16 @@
/**
* ThreadPool ("number of workers in a factory")
- *
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ *
+ * Codes with minor comments are from
+ *
+ * http://www.caveofprogramming.com/youtube/
+ *
+ *
* also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
+ * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
*
* @author Z.B. Celik
*/
@@ -25,7 +31,7 @@ public void run() {
System.out.println("Starting: " + id);
try {
Thread.sleep(5000);
- } catch (InterruptedException e) {
+ } catch (InterruptedException ignored) {
}
System.out.println("Completed: " + id);
}
@@ -45,7 +51,7 @@ public static void main(String[] args) {
System.out.println("All tasks submitted.");
try {
executor.awaitTermination(1, TimeUnit.DAYS);
- } catch (InterruptedException e) {
+ } catch (InterruptedException ignored) {
}
System.out.println("All tasks completed.");
}
diff --git a/JavaMultiThreadingCodes/src/ThreadPools_5/WorkerThreadPool.java b/JavaMultiThreadingCodes/src/ThreadPools_5/WorkerThreadPool.java
index 1535f50..6251a4f 100644
--- a/JavaMultiThreadingCodes/src/ThreadPools_5/WorkerThreadPool.java
+++ b/JavaMultiThreadingCodes/src/ThreadPools_5/WorkerThreadPool.java
@@ -8,19 +8,25 @@
import java.util.concurrent.TimeUnit;
/**
- * This is the implementation of LockObjects_4.Worker with threadPool
- *
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ * This is the implementation of {@link LockObjects_4.Worker} with threadPool
+ *
+ * Codes with minor comments are from
+ *
+ * http://www.caveofprogramming.com/youtube/
+ *
+ *
* also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
+ * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
*
* @author Z.B. Celik
*/
class Worker implements Runnable {
private Random random = new Random();
- private Object lock1 = new Object();
- private Object lock2 = new Object();
+ private final Object lock1 = new Object();
+ private final Object lock2 = new Object();
public List list1 = new ArrayList<>();
public List list2 = new ArrayList<>();
@@ -64,21 +70,21 @@ public void stageTwo() {
public class WorkerThreadPool {
public static void main(String[] args) {
- ExecutorService executer = Executors.newFixedThreadPool(2);//two threads, try setting by 1 to observe time
+ ExecutorService executor = Executors.newFixedThreadPool(2);//two threads, try setting by 1 to observe time
System.out.println("Starting ...");
long start = System.currentTimeMillis();
Worker worker = new Worker();
for (int i = 0; i < 2; i++) {//worker.run is called 2 (threads started) times by two threads
- executer.submit(worker);
+ executor.submit(worker);
}
- executer.shutdown(); //prevents new tasks from being accepted by the ExecutorService
+ executor.shutdown(); //prevents new tasks from being accepted by the ExecutorService
try {
- executer.awaitTermination(1, TimeUnit.DAYS);
- // How long should I wait for termination If I donot know exactly when threads are done with the tasks ?
+ executor.awaitTermination(1, TimeUnit.DAYS);
+ // How long should I wait for termination If I do not know exactly when threads are done with the tasks ?
// Source:http://stackoverflow.com/questions/1250643/how-to-wait-for-all-threads-to-finish-using-executorservice
- // For a perpetually running batch kind of thing u need to submit jobs and wait for them to
- // finish before jumping ahead.
- // In Such a case a latch or a barrier makes more sense than a shutdown (see CountDownLatch_6.App).
+ // For a perpetually running batch kind of thing u need to submit jobs and wait for them to
+ // finish before jumping ahead.
+ // In Such a case a latch or a barrier makes more sense than a shutdown (see CountDownLatch_6.App).
} catch (InterruptedException ex) {
System.out.println(ex.getMessage());
}
diff --git a/JavaMultiThreadingCodes/src/VolatileKeyword_2/App.java b/JavaMultiThreadingCodes/src/VolatileKeyword_2/App.java
index cc9ba8e..027ac29 100644
--- a/JavaMultiThreadingCodes/src/VolatileKeyword_2/App.java
+++ b/JavaMultiThreadingCodes/src/VolatileKeyword_2/App.java
@@ -1,12 +1,18 @@
package VolatileKeyword_2;
/**
- * Volatile Keyword, “… the volatile modifier guarantees that any thread that
- * reads a field will see the most recently written value.” - Josh Bloch
- *
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ * Volatile Keyword, “… the volatile modifier guarantees that any thread that
+ * reads a field will see the most recently written value.” - Josh Bloch
+ *
+ * Codes with minor comments are from
+ *
+ * http://www.caveofprogramming.com/youtube/
+ *
+ *
* also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
+ * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
*
* @author Z.B. Celik
*/
diff --git a/JavaMultiThreadingCodes/src/WaitAndNotify_8/App.java b/JavaMultiThreadingCodes/src/WaitAndNotify_8/App.java
index 4cc108e..c6e2b07 100644
--- a/JavaMultiThreadingCodes/src/WaitAndNotify_8/App.java
+++ b/JavaMultiThreadingCodes/src/WaitAndNotify_8/App.java
@@ -1,14 +1,21 @@
package WaitAndNotify_8;
/**
- * wait and notify in Java; low-level multithreading methods of the Object class
+ * {@link Object#wait()} and {@link Object#notify()} in Java; low-level
+ * multi-threading methods of the {@link java.lang.Object} class
* that allow you to have one or more threads sleeping, only to be woken up by
* other threads at the right moment. Extremely useful for avoiding those
* processor-consuming "polling loops".
- *
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ *
+ * Codes with minor comments are from
+ *
+ * http://www.caveofprogramming.com/youtube/
+ *
+ *
* also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
+ * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
*
* @author Z.B. Celik
*/
@@ -21,9 +28,7 @@ public static void main(String[] args) throws InterruptedException {
public void run() {
try {
processor.produce();
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
+ } catch (InterruptedException ignored) {}
}
});
@@ -32,11 +37,10 @@ public void run() {
public void run() {
try {
processor.consume();
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
+ } catch (InterruptedException ignored) {}
}
});
+
t1.start();
t2.start();
t1.join();
diff --git a/JavaMultiThreadingCodes/src/WaitAndNotify_8/BlockingQueueApp.java b/JavaMultiThreadingCodes/src/WaitAndNotify_8/BlockingQueueApp.java
index 23c61d8..99f76ca 100644
--- a/JavaMultiThreadingCodes/src/WaitAndNotify_8/BlockingQueueApp.java
+++ b/JavaMultiThreadingCodes/src/WaitAndNotify_8/BlockingQueueApp.java
@@ -9,42 +9,49 @@
/**
* Source:
- * http://stackoverflow.com/questions/2536692/a-simple-scenario-using-wait-and-notify-in-java
- * Firstly, you need to ensure that any calls to wait() or notify() are within a
- * synchronized region of code (with the wait() and notify() calls being
- * synchronized on the "same" object). The reason for this (other than the
- * standard thread safety concerns) is due to something known as a missed
- * signal.
- *
- * An example of this, is that a thread may call put() when the queue happens to
- * be full, it then checks the condition, sees that the queue is full, however
+ * http://stackoverflow.com/questions/2536692/a-simple-scenario-using-wait-and-notify-in-java
+ *
+ * Firstly, you need to ensure that any calls to {@code wait() or notify()} are
+ * within a synchronized region of code (with the {@code wait() or notify()}
+ * calls being synchronized on the "same" object).
+ * The reason for this (other than the standard thread safety concerns) is
+ * due to something known as a missed signal.
+ *
+ * An example of this, is that a thread may call {@link WaitAndNotify_8.BlockingQueue#put}
+ * when the queue happens to be full, it then checks the condition, sees that
+ * the queue is full, however
* before it can block another thread is scheduled. This second thread then
- * take()'s an element from the queue, and notifies the waiting threads that the
+ * {@link WaitAndNotify_8.BlockingQueue#take()}'s an element from the queue,
+ * and notifies the waiting threads that the
* queue is no longer full. Because the first thread has already checked the
- * condition however, it will simply call wait() after being re-scheduled, even
- * though it could make progress.
- *
+ * condition. However, it will simply call {@code wait()} after being
+ * re-scheduled, even though it could make progress.
+ *
* By synchronizing on a shared object, you can ensure that this problem does
- * not occur, as the second thread's take() call will not be able to make
- * progress until the first thread has actually blocked.
- *
+ * not occur,as the second thread's {@link WaitAndNotify_8.BlockingQueue#take()}
+ * call will not be able to make progress until the first thread has actually
+ * blocked.
+ *
* You must hold the lock (synchronized) before invoking wait/notify. Threads
* also have to acquire lock before waking.
- *
- * More:In order to wait on an object, we must be synchronized on that object.
+ *
+ * More: In order to wait on an object, we must be synchronized on that object.
+ *
* But our thread will automatically release the lock temporarily while waiting.
- * Calling wait() means that our thread will be suspended until it is
+ * Calling {@code wait()} means that our thread will be suspended until it is
* "notified". Our thread will be "notified", and thus woken up, when another
- * thread calls notify() on the object that we're waiting on (in this case, the
- * connection list). When our thread wakes up, it automatically regains the
+ * thread calls {@code notify()} on the object that we're waiting on (in this
+ * case, the connection list).
+ * When our thread wakes up, it automatically regains the
* lock. We can now check again that the list is not empty, and if it isn't,
* safely take out the first connection. This checking and removing will be
* atomic because we have the lock on the list.
*
- * @author Z.B. Celik
*
+ * @author Z.B. Celik
*/
-//For the other version of the implementation please check LowLevelProducerConsumer_9.App
+//For the other version of the implementation please check
+// LowLevelProducerConsumer_9.App
class BlockingQueue {
private Queue queue = new LinkedList<>();
@@ -63,12 +70,12 @@ public void put(T element) throws InterruptedException {
try {
while (queue.size() == capacity) {
System.out.println("queue is full cannot put");
- notFull.await();//releases lock
+ notFull.await(); //releases lock
}
queue.add(element);
System.out.println("Added to the queue " + element);
- notEmpty.signal();//call waiting thread on same object
+ notEmpty.signal(); //calls waiting thread on the same object
} finally {
lock.unlock();
}
@@ -79,12 +86,12 @@ public T take() throws InterruptedException {
try {
while (queue.isEmpty()) {
System.out.println("queue is empty, cannot take");
- notEmpty.await();//releases lock
+ notEmpty.await(); //releases lock
}
T item = queue.remove();
System.out.println("Removed to the queue " + item);
- notFull.signal();//call waiting thread on same object
+ notFull.signal(); //calls waiting thread on same object
return item;
} finally {
lock.unlock();
@@ -92,6 +99,7 @@ public T take() throws InterruptedException {
}
}
+@SuppressWarnings("InfiniteLoopStatement")
public class BlockingQueueApp {
public static void main(String[] args) throws InterruptedException {
@@ -103,9 +111,7 @@ public void run() {
while (true) {
blockingQueue.put(random.nextInt(10));
}
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
+ } catch (InterruptedException ignored) {}
}
});
@@ -120,9 +126,7 @@ public void run() {
while (true) {
blockingQueue.take();
}
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
+ } catch (InterruptedException ignored) {}
}
});
t1.start();
diff --git a/JavaMultiThreadingCodes/src/WaitAndNotify_8/Processor.java b/JavaMultiThreadingCodes/src/WaitAndNotify_8/Processor.java
index bf4ca1a..21171c1 100644
--- a/JavaMultiThreadingCodes/src/WaitAndNotify_8/Processor.java
+++ b/JavaMultiThreadingCodes/src/WaitAndNotify_8/Processor.java
@@ -3,31 +3,48 @@
import java.util.Scanner;
/**
- * Some background knowledge
- * Source:http://www.programcreek.com/2009/02/notify-and-wait-example/
- * synchronized keyword is used for exclusive accessing. To make a method
- * synchronized, simply add the synchronized keyword to its declaration. Then no
- * two invocations of synchronized methods on the same object can interleave
- * with each other. Synchronized statements must specify the object that
- * provides the intrinsic lock. When synchronized(this) is used, you have to
- * avoid to synchronizing invocations of other objects' methods. wait() tells
+ * Some background knowledge
+ * Source: http://www.programcreek.com/2009/02/notify-and-wait-example/
+ *
+ * {@code synchronized} keyword is used for exclusive accessing. To make a
+ * method {@code synchronized}, simply add the {@code synchronized} keyword to its
+ * declaration.
+ * Then no two invocations of synchronized methods on the same object can
+ * interleave with each other.
+ *
+ * Synchronized statements must specify the object that
+ * provides the intrinsic lock. When {@code synchronized(this)} is used, you
+ * have to avoid to synchronizing invocations of other objects' methods.
+ *
+ * {@link Object#wait()} tells
* the calling thread to give up the lock and go to sleep (not polling) until
- * some other thread enters the same lock and calls notify(). notify() wakes up
- * the first thread that called wait() on the same object.
- *
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ * some other thread enters the same lock and calls {@link Object#notify()}.
+ *
+ * {@link Object#notify()} wakes up the first thread that called wait() on
+ * the same object.
+ *
+ * Codes with minor comments are from
+ *
+ * http://www.caveofprogramming.com/youtube/
+ *
+ *
* also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
+ * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ *
*
* @author Z.B. Celik
*/
public class Processor {
- /**
+ /*
* public synchronized void getSomething(){ this.hello = "hello World"; }
* public void getSomething(){ synchronized(this){ this.hello = "hello
- * World"; } , two code blocks by specification, functionally identical.
+ * World"; } }
+ * two code blocks by specification, functionally identical.
*/
+
+
public void produce() throws InterruptedException {
synchronized (this) {
System.out.println("Producer thread running ....");
@@ -45,6 +62,7 @@ public void consume() throws InterruptedException {
System.out.println("Return key pressed.");
notify();
Thread.sleep(5000);
+ System.out.println("Consumption done.");
}
}
}
diff --git a/README.md b/README.md
index 873dc08..6d91e04 100644
--- a/README.md
+++ b/README.md
@@ -1,32 +1,28 @@
+# Java Multithreading
+This repository contains all the codes required for the ultimate John Purcell's [Java-MultiThreading](https://caveofprogramming.teachable.com/p/java-multithreading) course.
-Java Multithreading
-=============================================================
-This repository will contain all the codes for the ultimate Java multithreading course by John Purcell
+We recommend the codes for those interested in understanding the multithreading. The code is written in Java and the topics are numbered by following the lecture content.
-See the [Video Tutorials](https://www.udemy.com/java-multithreading/)
-for more information.
-Contributor
-----------
-[Z.B. Celik] (http://www.linkedin.com/in/berkaycelik)
+## Java Multithreading Topics:
+- 1- Java Multithreading: Starting Threads
+- 2- Java Multithreading: Volatile – Basic Thread Communication
+- 3- Java Multithreading: Synchronized
+- 4- Java Multithreading: Lock Objects
+- 5- Java Multithreading: Thread Pools
+- 6- Java Multithreading: Countdown Latches
+- 7- Java Multithreading: Producer-Consumer
+- 8- Java Multithreading: Wait and Notify
+- 9- Java Multithreading: Low-Level Producer-Consumer
+- 10- Java Multithreading: Re-entrant Locks
+- 11- Java Multithreading: Deadlock
+- 12- Java Multithreading: Semaphores
+- 13- Java Multithreading: Callable and Future
+- 14- Java Multithreading: Interrupting Threads
-Java Multithreading Topics:
--------------
-Codes with minor comments are from http://www.caveofprogramming.com/youtube/ also freely available at https://www.udemy.com/java-multithreading/?couponCode=FREE
+## Contributors
+[Z. Berkay Celik](https://twitter.com/ZBerkayCelik)
-- 1- Java Multithreading: Starting Threads
-- 2- Java Multithreading: Volatile – Basic Thread Communication
-- 3- Java Multithreading: Synchronized
-- 4- Java Multithreading: Lock Objects
-- 5- Java Multithreading: Thread Pools
-- 6- Java Multithreading: Countdown Latches
-- 7- Java Multithreading: Producer-Consumer
-- 8- Java Multithreading: Wait and Notify
-- 9- Java Multithreading: Low-Level Producer-Consumer
-- 10- Java Multithreading: Re-entrant Locks
-- 11- Java Multithreading: Deadlock
-- 12- Java Multithreading: Semaphores
-- 13- Java Multithreading: Callable and Future
-- 14- Java Multithreading: Interrupting Threads
+[@IOAyman](https://twitter.com/IOAyman)