What is Synchronized
keyword?
Synchronized keyword is used to provide mutual
exclusive access of a shared resource with multiple threads.
Synchronization guarantees that, no two threads can execute a
synchronized method which requires same lock simultaneously or concurrently.
How it works?
Whenever a thread enters into synchronized method or
block it acquires a lock and whenever it leaves
synchronized method or block it releases the lock.
Lock is released even if thread leaves synchronized method after
completion or due to any Error or Exception.
Object or Class
level locking?
Thread acquires an object level lock when it
enters into an instance synchronized method and acquires a class
level lock when it enters into static synchronized method.
synchronized keyword
is re-entrant in nature
It means if a synchronized method calls another synchronized
method which requires same lock then current thread which is holding
lock can enter into that method without acquiring lock.
NullPointerException
synchronization will
throw NullPointerException if object used synchronized block
is null.synchronized(instance) will
throws java.lang.NullPointerException if instance is null.
synchronized block
is better than synchronized method
synchronized block is better than synchronized method in Java
because by using synchronized block, it lock only critical section of code and
avoid locking whole method which can possibly degrade performance.
It’s possible that both static synchronized and non-static
synchronized method can run simultaneously or concurrently because they lock on
different object.
volatile keyword usage
– To avoid the memory consistency error
From java 5 after change in Java memory model reads and
writes are atomic for all variables declared using volatile keyword (including
long and double variables) and simple atomic variable access is more efficient
instead of accessing these variables via synchronized java code. But it
requires more care and attention from the programmer to avoid memory
consistency errors.
synchronized keyword
with constructor
According to the Java language specification we cannot use Java synchronized keyword with constructor it’s
illegal and result in compilation error. So you cannot synchronized constructor
which seems logical because other threads cannot see the object being created until
the thread creating it has finished it.
Reentrant lock
Java.util.concurrent.locks extends capability provided
by synchronized keyword for writing more sophisticated programs since they
offer more capabilities e.g. Reentrancy and interruptible locks.
synchronized
keyword also synchronizes memory.
In fact synchronized synchronizes the whole of thread memory
with main memory.
Important method related to synchronization in are wait (), notify()
and notifyAll() which is defined in Object class always call in
synchronized block or method.
Do not synchronize non-final
field on synchronized block
Because reference of non-final field may change any time and
then different thread might synchronizing on different objects i.e. no
synchronization at all.
private String lock = new String("lock");
// non-final.
synchronized(lock){
System.out.println("locking on :" + lock);
}
synchronized code may get warning "Synchronization
on non-final field" in IDE like Netbeans and InteliJ.
Do not String object
as lock in java synchronized block
It is not recommended to use String object as lock in
java synchronized block because string is immutable
object and literal string and interned string gets stored in String pool.
So by any chance if any other part of code or any third party
library used same String as there lock then they both will be locked on same
object despite being completely unrelated which could result in unexpected
behavior and bad performance.
Instead of String object it’s advised to use new Object ()
for Synchronization in Java on synchronized block.
private static final String
LOCK = "lock"; //not recommended
private static final Object
OBJ_LOCK = new Object(); //better
public void process() {
synchronized(LOCK) {
........
}
}
Calendar
and SimpleDateFormat
From Java library Calendar and SimpleDateFormat
classes are not thread-safe , requires external
synchronization in Java to be used in multi-threaded environment.
No comments:
Post a Comment