How To Purpose Locks Inwards Multi-Threaded Coffee Program

Many Java programmers confused themselves similar hell land writing multi-threaded Java programs e.g. where to synchronized? Which Lock to use? What Lock to usage etc. I oft have asking to explicate virtually how to usage Locks inward Java, therefore 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 sack live anything e.g. database, File system, a Prime number Generator or a Message processor. Before using Locks inward Java program, it’s also meliorate to larn merely about basics. Lock is an interface from java.util.concurrent package. It was introduced inward JDK 1.5 liberate equally an choice of synchronized keyword. If you lot have got never written whatsoever multi-threading program, therefore I advise commencement start amongst synchronized keyword because it’s easier to usage them. Once you lot are familiar amongst working of multi-threading plan e.g. How threads part data, how inter thread communication works, you lot tin sack start amongst Lock facility. As I told you lot Lock is an interface, therefore nosotros cannot usage it directly, instead nosotros demand to usage its implementation class. Thankfully Java comes amongst 2 implementation of java.util.concurrent.locks.Lock interface, ReentrantLock as well as ReentrantReadWriteLock, subsequently provides 2 to a greater extent than inner implementation known equally ReentrantReadWriteLock.ReadLock as well as ReentrantReadWriteLock.WriteLock. For our uncomplicated multi-threaded Java program's operate ReentrantLock is enough.
Here is the idiom to usage Locks inward Java :

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

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

For representative nosotros tin sack usage Lock to protect a counter, whose sole operate 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, therefore 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 liberate lock.

Always recollect to liberate lock inward lastly block, because every object has solely 1 lock as well as if a thread doesn't liberate it therefore no 1 tin sack acquire it, which may number inward your plan 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 equally presently equally 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 inward lastly block, to brand certain it run fifty-fifty if attempt block throws exception or not.

In side past times side department nosotros volition run across representative 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 representative it’s an object, a counter's object. Invariant of Counter course of written report is to render a count incremented past times 1 each fourth dimension mortal calls getCount() method. Here for testing 3 threads volition telephone band getCount() method simultaneously but guard provided past times Lock volition preclude shared counter. As an exercise you lot tin sack also implement same course of written report using synchronized keyword. Here is consummate code :

import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock;  /**  *  * Java Program to present how to usage Locks inward 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 sack fifty-fifty lay a long loop within Runnable's run() method to telephone band getCount() numerous time, if you lot run across a duplicate agency at that spot is a employment amongst your code, but without whatsoever duplicate agency it’s working fine.

Common Mistakes made past times beginners land using Locks inward Java

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

1) Instead of sharing lock they render dissimilar locks to each thread. This oft happens to them unknowingly because they commonly lay the lock as well as guarded block within Runnable, as well as they top 2 different instances of Runnable to 2 dissimilar threads e.g. where SimpleLock is a Runnable, equally 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 agency firstThread as well as secondThread are using dissimilar lock as well as they tin sack run protected code simultaneously.

2) Second error Java beginners do is forget to telephone band unlock() method, merely similar inward a higher house example. without calling unlock() method, Thread volition non liberate its lock as well as merely about other thread waiting for that lock volition never acquire that. Nothing volition come about inward this assay out program, but 1 time you lot write this sort of code inward 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, depository fiscal establishment jibe here to larn more.

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

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

Sumber https://javarevisited.blogspot.com/

Share this post