How To Piece Of Job Locks Inwards Multi-Threaded Coffee Program

Many Java programmers confused themselves similar hell spell writing multi-threaded Java programs e.g. where to synchronized? Which Lock to use? What Lock to work etc. I frequently have asking to explicate nearly how to work Locks inwards Java, thus I idea to write a uncomplicated Java program, which is multi-threaded as well as uses rather novel Lock interface. Remember Lock is your tool to guard shared resources which tin live anything e.g. database, File system, a Prime number Generator or a Message processor. Before using Locks inwards Java program, it’s also ameliorate to larn or thus basics. Lock is an interface from java.util.concurrent package. It was introduced inwards JDK 1.5 loose every bit an choice of synchronized keyword. If you lot have got never written whatever multi-threading program, as well as thus I advise commencement start amongst synchronized keyword because it’s easier to work them. Once you lot are familiar amongst working of multi-threading programme e.g. How threads part data, how inter thread communication works, you lot tin start amongst Lock facility. As I told you lot Lock is an interface, thus nosotros cannot work it directly, instead nosotros demand to work its implementation class. Thankfully Java comes amongst 2 implementation of java.util.concurrent.locks.Lock interface, ReentrantLock as well as ReentrantReadWriteLock, afterward provides 2 to a greater extent than inner implementation known every bit ReentrantReadWriteLock.ReadLock as well as ReentrantReadWriteLock.WriteLock. For our uncomplicated multi-threaded Java program's piece of work ReentrantLock is enough.
Here is the idiom to work Locks inwards Java :

Lock l = ...; l.lock();  try {     // access the resources protected past times this lock  } finally {    l.unlock(); }
 

You tin run across that Lock is used to protect a resource, thus that exclusively 1 thread tin access it at a time. Why nosotros do that? to brand certain our application comport properly.

For instance nosotros tin work Lock to protect a counter, whose sole piece of work is to render a count incremented past times one, when anyone calls its getCount() method. If nosotros don't protect them past times parallel access of thread, as well as thus it’s possible that 2 thread receives same count, which is against the program's policies.

Now, coming dorsum to semantics, nosotros have got used lock() method to acquire lock as well as unlock() method to loose lock.

Always recall to loose lock inwards hold upwardly block, because every object has exclusively 1 lock as well as if a thread doesn't loose it as well as thus no 1 tin acquire it, which may upshot inwards your programme hung or threads going into deadlock.

That's why I said that synchronized keyword is simpler than lock, because Java itself brand certain that lock acquired past times thread past times entering into synchronized block or method is released every bit shortly every bit it came out of the block or method. This happens fifty-fifty if thread came out past times throwing exception, this is also nosotros have got unlock code inwards hold upwardly block, to brand certain it run fifty-fifty if endeavor block throws exception or not.

In side past times side department nosotros volition run across instance of our multi-threaded Java program, which uses Lock to protect shared Counter.

Java Lock as well as ReentrantLock Example

Here is a sample Java program, which uses both Lock as well as ReentrantLock to protect a shared resource. In our instance it’s an object, a counter's object. Invariant of Counter flat is to render a count incremented past times 1 each fourth dimension mortal calls getCount() method. Here for testing 3 threads volition telephone telephone getCount() method simultaneously but guard provided past times Lock volition preclude shared counter. As an exercise you lot tin also implement same flat using synchronized keyword. Here is consummate code :

import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock;  /**  *  * Java Program to exhibit how to work Locks inwards multi-threading   * e.g. ReentrantLock, ReentrantReadWriteLock etc.  *  * @author Javin Paul  */ public class LockDemo {      public static void main(String args[]) {          // Let's do a counter as well as shared it betwixt 3 threads         // Since Counter needs a lock to protect its getCount() method         // nosotros are giving it a ReentrantLock.         final Counter myCounter = new Counter(new ReentrantLock());          // Task to live executed past times each thread         Runnable r = new Runnable() {             @Override             public void run() {                 System.out.printf("Count at thread %s is %d %n",                         Thread.currentThread().getName(), myCounter.getCount());             }         };          // Creating 3 threads         Thread t1 = new Thread(r, "T1");         Thread t2 = new Thread(r, "T2");         Thread t3 = new Thread(r, "T3");          //starting all threads         t1.start();         t2.start();         t3.start();     } }

class Counter {     private Lock lock; // Lock to protect our counter     private int count; // Integer to concur count      public Counter(Lock myLock) {         this.lock = myLock;     }      public final int getCount() {         lock.lock();         try {             count++;             return count;         } finally {             lock.unlock();         }              } } Output: Count at thread T1 is 1 Count at thread T2 is 2 Count at thread T3 is 3

You tin fifty-fifty pose a long loop within Runnable's run() method to telephone telephone getCount() numerous time, if you lot run across a duplicate way at that topographic point is a job amongst your code, but without whatever duplicate way it’s working fine.

Common Mistakes made past times beginners spell using Locks inwards Java

Here are or thus of the mutual mistakes I have got observed past times looking at Java beginners lock related code :

1) Instead of sharing lock they supply unlike locks to each thread. This frequently happens to them unknowingly because they commonly pose the lock as well as guarded block within Runnable, as well as they overstep 2 different instances of Runnable to 2 unlike threads e.g. where SimpleLock is a Runnable, every bit shown below :

Thread firstThread = new Thread(new SimpleLock()); Thread secondThread = new Thread(new SimpleLock());  class SimpleLock implements Runnable {         private Lock myLock = new ReentrantLock();         public void printOutput() {             System.out.println("Hello!");         }         public void run() {             if (myLock.tryLock()) {                 myLock.lock();                 printOutput();             }else                 System.out.println("The lock is non accessible.");         }     }

Since hither myLock is instance variable, each instance of SimpleLock has their ain myLock instance, which way firstThread as well as secondThread are using unlike lock as well as they tin run protected code simultaneously.

2) Second fault Java beginners do is forget to telephone telephone unlock() method, only similar higher upwardly example. without calling unlock() method, Thread volition non loose its lock as well as or thus other thread waiting for that lock volition never acquire that. Nothing volition hand off inwards this bear witness program, but 1 time you lot write this sort of code inwards existent application, you lot volition run across nasty issues similar deadlock, starvation as well as information corruption.  By the way Lock interface also offers several advantages over synchronized keyword, banking concern fit here to larn more.

That's all nearly how to work Locks inwards multi-threaded Java programme for synchronization. Let me know if you lot have got whatever hard agreement Locks inwards Java or anything related to multi-threading, Will live glad to assist you. For farther reading, you lot tin explore Java documentation of Lock interface as well as it's diverse implementation classes

Further Learning
Multithreading as well as Parallel Computing inwards Java
Java Concurrency inwards Practice - The Book
Applying Concurrency as well as Multi-threading to Common Java Patterns
Java Concurrency inwards Practice Course past times Heinz Kabutz