Synchronization in Java is a fundamental concept that ensures thread safety in multi-threaded programming. It allows developers to control the access of multiple threads to shared resources, preventing inconsistent behavior and data corruption. This blog dives into the details of synchronization in Java, its importance, and how to implement it effectively.<\/p>\n\n\n\n
In Java, synchronization is the capability to control the access of multiple threads to shared resources. It ensures that only one thread can access a synchronized block or method at a time, thus maintaining data integrity.<\/p>\n\n\n\n
Java\u2019s synchronization mechanism is built around the concept of monitors. Every object in Java has an intrinsic lock (or monitor lock) that is used for synchronization. When a thread enters a synchronized block or method, it acquires the lock associated with the object. Other threads attempting to access the same synchronized block or method must wait until the lock is released.<\/p>\n\n\n\n
java.util.concurrent<\/code> package over low-level synchronization when possible. These utilities simplify the implementation and reduce errors in Synchronization in Java.<\/li>\n\n\n\n- Document Synchronization Logic:<\/strong>
Clearly document the purpose and scope of synchronization in your code. Properly documenting Synchronization in Java improves maintainability and helps other developers understand the logic.<\/li>\n\n\n\n- Test Thoroughly:<\/strong>
Multi-threaded code can be challenging to debug. Use robust testing strategies, including stress tests, to identify and resolve issues with Synchronization in Java early in the development process.<\/li>\n<\/ul>\n\n\n\nThread Synchronization in Java<\/strong><\/h2>\n\n\n\nJava provides built-in synchronization in Java mechanisms for managing access to shared resources. These include:<\/p>\n\n\n\n
1. Synchronized Methods<\/strong><\/h3>\n\n\n\nThe synchronized<\/code> a keyword can be applied to methods to restrict access to one thread at a time.<\/p>\n\n\n\njava public synchronized void synchronizedMethod() {\n \/\/ Critical section\n}\n<\/code><\/code><\/pre>\n\n\n\nWhen a thread invokes a synchronized method, it acquires the intrinsic lock (monitor lock)<\/strong> on the object. Other threads trying to access the synchronized method on the same object are blocked until the lock is released.<\/p>\n\n\n\nIn the Java platform<\/a>, synchronization in Java is the capability to control access to shared resources that can be shared between threads or processes. We will talk about thread synchronization because it’s a more common task. Threads can access the same fields and the object’s references. Without correct synchronization is can cause thread interference, memory consistency errors or unexpected behavior of your application.<\/p>\n\n\n\nLet’s look at an example. It will help us to understand the problem without synchronization. Assuming that we have a user with a bank account. There are two transactions on that account with different duration. We are starting the longer transaction. Right after, we are calling the shorter one.<\/p>\n\n\n\n
public<\/strong> class<\/strong> SynchronizationExample {\npublic<\/strong> static<\/strong> void<\/strong> main(String[] args){\nAccount account = new<\/strong> Account();\nThread thread1 = new<\/strong> Transaction(account, 3000);\nThread thread2 = new<\/strong> Transaction(account, 1000);\nthread1.start();\nthread2.start();\n}\n}\n\nclass<\/strong> Transaction extends<\/strong> Thread {\nprivate<\/strong> int<\/strong> timeToWait;\nprivate<\/strong> Account account;\n\npublic<\/strong> Transaction(Account account,int<\/strong> timeToWait) {\nthis<\/strong>.timeToWait = timeToWait;\nthis<\/strong>.account = account;\n}\n\npublic<\/strong> void<\/strong> run() {\ntry<\/strong> {\naccount.performTransaction(timeToWait);\n} catch<\/strong> (InterruptedException e) {\ne.printStackTrace();\n}\n}\n}\n\nclass<\/strong> Account {\npublic<\/strong> void<\/strong> performTransaction(int<\/strong> timeToWait) throws<\/strong> InterruptedException {\nSystem.out<\/em><\/strong>.println(\"Before transaction \" + Thread.currentThread<\/em>().getId());\nThread.sleep<\/em>(timeToWait);\nSystem.out<\/em><\/strong>.println(\"After transaction \" + Thread.currentThread<\/em>().getId());\n}\n}\n<\/code><\/pre>\n\n\n\nThe output of this application will be:<\/p>\n\n\n\n
Before transaction 12\nBefore transaction 13\nAfter transaction 13\nAfter transaction 12<\/pre>\n\n\n\nThe output is inconsistent. The first transaction wasn’t finished, but the second already started. It can cause some problems for a bank client, who wants to know the real amount of money on his account after each transaction. <\/p>\n\n\n\n
Synchronization in Java is built on locks or monitors. A thread that needs consistent access has to acquire the lock before accessing them and release the lock when it’s done with them<\/p>\n\n\n\n
The Java platform allows us to do synchronization in different ways. It can be a synchronized method, synchronized block or static synchronization. <\/p>\n\n\n\n
We have to mention that constructor cannot be marked as synchronized. It will cause a syntax error because doesn’t have sense. Only the thread that creates that object should have access to its creation.Let’s mark our method performTransaction (int<\/strong> timeToWait) as synchronized. After this, our output will be:<\/p>\n\n\n\nBefore transaction 12\nAfter transaction 12\nBefore transaction 13\nAfter transaction 13<\/pre>\n\n\n\nThis means that two transactions were done one after one. The first thread locked the method performTransaction (int<\/strong> timeToWait) until finished his work. <\/p>\n\n\n\nLet’s use the synchronized block and get the same result:<\/p>\n\n\n\n
class<\/strong> Account {\npublic<\/strong> void<\/strong> performTransaction(int<\/strong> timeToWait) throws<\/strong> InterruptedException {\nsynchronized<\/strong> (this<\/strong>) {\nSystem.out<\/em><\/strong>.println(\"Before transaction \" + Thread.currentThread<\/em>().getId());\nThread.sleep<\/em>(timeToWait);\nSystem.out<\/em><\/strong>.println(\"After transaction \" + Thread.currentThread<\/em>().getId());\n}\n}\n}\n<\/code><\/pre>\n\n\n\nHere we specified the object for synchronized statements. That object provides the intrinsic lock. The scope of the synchronized block is usually smaller than the synchronized method scope. We are blocking the whole object. It is better sometimes to synchronize only a part of your method.<\/p>\n\n\n\n
Let’s look at a bit different example. We have a value that will be changed by two threads. The example of code without synchronization between threads:<\/p>\n\n\n\n
public<\/strong> class<\/strong> SynchronizationExample {\npublic<\/strong> static<\/strong> void<\/strong> main(String[] args) throws<\/strong> InterruptedException {\nClientAccount account = new<\/strong> ClientAccount();\nSystem.out<\/em><\/strong>.println(\"Account balance before all transactions is \" + account.getBalance());\n\/\/transaction to send 100 to account\nThread thread1 = new<\/strong> Transaction(account,100,3000);\n\/\/transaction to get 50 from account\nThread thread2 = new<\/strong> Transaction(account,-50,1000);\n\nthread1.start();\nthread2.start();\n}\n}\n\nclass<\/strong> Transaction extends<\/strong> Thread {\nprivate<\/strong> int<\/strong> timeToWait;\nprivate<\/strong> int<\/strong> value;\nprivate<\/strong> ClientAccount account;\n\npublic<\/strong> Transaction(ClientAccount account, int<\/strong> value, int<\/strong> timeToWait) {\nthis<\/strong>.timeToWait = timeToWait;\nthis<\/strong>.value = value;\nthis<\/strong>.account = account;\n}\n\npublic<\/strong> void<\/strong> run() {\ntry<\/strong> {\naccount.changeBalance(value, timeToWait);\n} catch<\/strong> (InterruptedException e) {\ne.printStackTrace();\n}\n}\n}\n\nclass<\/strong> ClientAccount {\nprivate<\/strong> Integer<\/strong> balance = 0;\npublic<\/strong> void<\/strong> changeBalance(int<\/strong> value, int<\/strong> time) throws<\/strong> InterruptedException {\nbalance += value;\nThread.sleep<\/em>(time);\nSystem.out<\/em><\/strong>.println(\"Account balance after \" + value + \" is \" + balance);\n}\npublic<\/strong> int<\/strong> getBalance() {\nreturn<\/strong> balance;\n}\n}\n<\/code><\/pre>\n\n\n\nThe output will be:<\/p>\n\n\n\n
Account balance before all transactions is 0\nAccount balance after -50 is 50\nAccount balance after 100 is 50<\/pre>\n\n\n\nOur client had a balance 0. We started two transactions. The first was to transfer to the client account 100. The second was to transfer from account 50. The application result looks not logical: <\/p>\n\n\n\n
0-50 = 50; <\/p>\n\n\n\n
50+100 = 50;<\/p>\n\n\n\n
The reason is simple. The two treads entered the method changeBalance(int<\/strong> value, int<\/strong> time). The first thread takes more time. That is why the second one raced it. Finally, we got the messy output.<\/p>\n\n\n\nWe can to synchronize access of our treads to the balance value. Let’s use the synchronized block for this:<\/p>\n\n\n\n
class<\/strong> ClientAccount {\nprivate<\/strong> Integer balance = 0;\n\npublic<\/strong> void<\/strong> changeBalance(int<\/strong> value, int<\/strong> time) throws<\/strong> InterruptedException {\nsynchronized<\/strong> (balance) {\nbalance += value;\nThread.sleep<\/em>(time);\nSystem.out<\/em><\/strong>.println(\"Account balance after \" + value + \" is \" + balance);\n}\n}\n...\n}\n<\/code><\/pre>\n\n\n\nNow, our output is consistent and understandable:<\/p>\n\n\n\n
Account balance before all transactions is 0\nAccount balance after 100 is 100\nAccount balance after -50 is 50<\/pre>\n\n\n\nThe syntax of the synchronized block is:\nsynchronized (object reference expression) { \n \/\/code block \n}\n<\/pre>\n\n\n\nIt is important to note that object reference expression has to be an Object, we cannot use primitive types. That is why we used the object wrapper for int in our example. You will get a java.lang.NullPointerException, in case object reference expression of a synchronized block is null.<\/p>\n\n\n\n
We can create a synchronized class. In this case, all methods of this class will be declared as synchronization in Java . For example, Vector, Stack, Hashtable, StringBuffer. They are not recommended for use. The reason is that they are slow.<\/p>\n\n\n\n
Static synchronization is when you use synchronization for a static method. In this case, the all-class will be locked, not just object.<\/p>\n\n\n\n
public<\/strong> class<\/strong> StaticSynchExample {\npublic<\/strong> static<\/strong> void<\/strong> main(String[] args){\nThread thread1 = new<\/strong> Printer(1);\nThread thread2 = new<\/strong> Printer(2);\nthread1.start();\nthread2.start();\n}\n}\n\nclass<\/strong> Printer extends<\/strong> Thread {\nprivate<\/strong> int<\/strong> k;\npublic<\/strong> Printer(int<\/strong> k) {\nthis<\/strong>.k = k;\n}\npublic<\/strong> void<\/strong> run() {\ntry<\/strong> {\nDocument.print<\/em>(k);\n} catch<\/strong> (InterruptedException e) {\ne.printStackTrace();\n}\n}\n}\n\nclass<\/strong> Document {\nprivate<\/strong> static<\/strong> int<\/strong> K<\/em> = 1;\npublic<\/strong> static<\/strong> synchronized<\/strong> void<\/strong> print(int<\/strong> k) throws<\/strong> InterruptedException {\nK<\/em> = k;\nSystem.out<\/em><\/strong>.print(\"Start\");\nfor<\/strong>(int<\/strong> i = 0; i < 5; i++) {\nSystem.out<\/em><\/strong>.print(i*K<\/em> + \" \");\n}\nSystem.out<\/em><\/strong>.println(\"End\");\n}\n}\n<\/code><\/pre>\n\n\n\nThe output will be not logical. The threads accessed and changed our coefficient randomly:<\/p>\n\n\n\n
Start Start 0 0 2 4 6 8 End\n2 4 6 8 End\n<\/pre>\n\n\n\nAfter marking our print(int k) method as synchronized, we will get consistent result:<\/p>\n\n\n\n
Start 0 1 2 3 4 End\nStart 0 2 4 6 8 End<\/pre>\n\n\n\nLet’s summarize the important things to know about the synchronized keyword. Synchronization guarantees that two threads cannot execute a synchronized method with the same lock simultaneously or concurrently. The synchronized keyword can be used for methods or blocks (synchronized statements). When a thread enters a synchronized part of code, the code acquires a lock. This lock exists until the thread leaves that code or an error\/exception occurs.<\/p>\n\n\n\n
A thread acquires an object level lock when enters an instance synchronized method. A thread acquires a class level lock when enters a static synchronized method. <\/p>\n\n\n\n
The synchronized keyword is re-entrant. Let’s explain it. A thread that holds a lock on one synchronized method does not need to acquire a lock for a synchronized method called from the first method.<\/p>\n\n\n\n
There is one main disadvantage of Java synchronized keyword. It doesn’t allow concurrent read. This limits scalability. You can use ReentrantReadWriteLock for this use case. It is from package java.util.concurrent.locks. It provides a ready implementation of the ReadWriteLock in Java.<\/p>\n\n\n\n
The synchronized keyword can control access to a shared object just within the same JVM.<\/p>\n\n\n\n
A synchronized method in Java is very slow. They degrade performance. So, it better to use blocks for critical sections of code.<\/p>\n\n\n\n