What does synchronized mean

Question

I have some questions regarding the usage and significance of the synchronized keyword     What is the significance of the synchronized keyword  When should methods be synchronized  What does it mean programmatically and logically

User · Answer

synchronized is a keyword in Java which is used to make happens before relationship in multithreading environment to avoid memory inconsistency and thread interference error

User · Answer

synchronized simple means no two threads can access the block method simultaneously  When we say any block method of a class is synchronized it means only one thread can access them at a time  Internally the thread which tries to access it first take a lock on that object and as long as this lock is not available no other thread can access any of the synchronized methods blocks of that instance of the class   Note another thread can access a method of the same object which is not defined to be synchronized  A thread can release the lock by calling  Object wait

User · Answer

Synchronized simply means that multiple threads if associated with single object can prevent dirty read and write if synchronized block is used on particular object  To give you more clarity   lets take an example    class MyRunnable implements Runnable       int var   10       Override     public void run             call               public void call             synchronized  this                for  int i   0  i  lt  4  i                      var                    System out println  Current Thread     Thread currentThread   getName       var value   var                                    public class MutlipleThreadsRunnable       public static void main String   args            MyRunnable runnable1   new MyRunnable            MyRunnable runnable2   new MyRunnable            Thread t1   new Thread runnable1           t1 setName  Thread -1            Thread t2   new Thread runnable2           t2 setName  Thread -2            Thread t3   new Thread runnable1           t3 setName  Thread -3            t1 start            t2 start            t3 start              We ve created two MyRunnable class objects   runnable1 being shared with thread 1 and thread 3  amp  runnable2 being shared with thread 2 only  Now when t1 and t3 starts without synchronized being used   PFB output which suggest that both threads 1 and 3 simultaneously affecting var value where for thread 2   var has its own memory   Without Synchronized keyword      Current Thread Thread -1 var value 11     Current Thread Thread -2 var value 11     Current Thread Thread -2 var value 12     Current Thread Thread -2 var value 13     Current Thread Thread -2 var value 14     Current Thread Thread -1 var value 12     Current Thread Thread -3 var value 13     Current Thread Thread -3 var value 15     Current Thread Thread -1 var value 14     Current Thread Thread -1 var value 17     Current Thread Thread -3 var value 16     Current Thread Thread -3 var value 18   Using Synchronzied  thread 3 waiting for thread 1 to complete in all scenarios  There are two locks acquired   one on runnable1 shared by thread 1 and thread 3 and another on runnable2 shared by thread 2 only   Current Thread Thread -1 var value 11 Current Thread Thread -2 var value 11 Current Thread Thread -1 var value 12 Current Thread Thread -2 var value 12 Current Thread Thread -1 var value 13 Current Thread Thread -2 var value 13 Current Thread Thread -1 var value 14 Current Thread Thread -2 var value 14 Current Thread Thread -3 var value 15 Current Thread Thread -3 var value 16 Current Thread Thread -3 var value 17 Current Thread Thread -3 var value 18

User · Answer

What is the synchronized keyword    Threads communicate primarily by sharing access to fields and the objects reference fields refer to  This form of communication is extremely efficient  but makes two kinds of errors possible  thread interference and memory consistency errors  The tool needed to prevent these errors is synchronization    Synchronized blocks or methods prevents thread interference and make sure that data is consistent  At any point of time  only one thread can access a synchronized block or method  critical section  by acquiring a lock  Other thread s  will wait for release of lock to access critical section       When are methods synchronized    Methods are synchronized when you add synchronized to method definition or declaration  You can also synchronize a particular block of code with-in a method       What does it mean pro grammatically and logically    It means that only one thread can access critical section by acquiring a lock  Unless this thread release this lock  all other thread s  will have to wait to acquire a lock  They don t have access to enter critical section with out acquiring lock   This can t be done with a magic  It s programmer  responsibility to identify critical section s  in application and guard it accordingly  Java provides a framework to guard your application  but where and what all sections to be guarded is the responsibility of programmer   More details from java documentation page  Intrinsic Locks and Synchronization      Synchronization is built around an internal entity known as the intrinsic lock or monitor lock  Intrinsic locks play a role in both aspects of synchronization  enforcing exclusive access to an object s state and establishing happens-before relationships that are essential to visibility    Every object has an intrinsic lock associated with it  By convention  a thread that needs exclusive and consistent access to an object s fields has to acquire the object s intrinsic lock before accessing them  and then release the intrinsic lock when it s done with them   A thread is said to own the intrinsic lock between the time it has acquired the lock and released the lock  As long as a thread owns an intrinsic lock  no other thread can acquire the same lock  The other thread will block when it attempts to acquire the lock      When a thread releases an intrinsic lock  a happens-before relationship is established between that action and any subsequent acquisition of the same lock     Making methods synchronized has two effects      First  it is not possible for two invocations of synchronized methods on the same object to interleave     When one thread is executing a synchronized method for an object  all other threads that invoke synchronized methods for the same object block  suspend execution  until the first thread is done with the object      Second  when a synchronized method exits  it automatically establishes a happens-before relationship with any subsequent invocation of a synchronized method for the same object     This guarantees that changes to the state of the object are visible to all threads   Look for other alternatives to synchronization in    Avoid synchronized this  in Java

User · Answer

Think of it as a kind of turnstile like you might find at a football ground  There are parallel steams of people wanting to get in but at the turnstile they are  synchronised   Only one person at a time can get through  All those wanting to get through will do  but they may have to wait until they can go through

User · Answer

volatile About    gt  synchronized synchronized block in Java is a monitor in multithreading  synchronized block with the same object class can be executed by only single thread  all others are waiting  It can help with race condition situation when several threads try to update the same variable  Java 5 extended synchronized by supporting happens-before About   An unlock  synchronized block or method exit  of a monitor happens-before every subsequent lock  synchronized block or method entry  of that same monitor   The next step is java util concurrent

User · Answer

Overview  Synchronized keyword in Java has to do with thread-safety  that is  when multiple threads read or write the same variable  This can happen directly  by accessing the same variable  or indirectly  by using a class that uses another class that accesses the same variable    The synchronized keyword is used to define a block of code where multiple threads can access the same variable in a safe way   Deeper  Syntax-wise the synchronized keyword takes an Object as it s parameter  called a lock object   which is then followed by a   block of code      When execution encounters this keyword  the current thread tries to  lock acquire own   take your pick  the lock object and execute the associated block of code after the lock has been acquired  Any writes to variables inside the synchronized code block are guaranteed to be visible to every other thread that similarly executes code inside a synchronized code block using the same lock object  Only one thread at a time can hold the lock  during which time all other threads trying to acquire the same lock object will wait  pause their execution   The lock will be released when execution exits the synchronized code block    Synchronized methods   Adding synchronized keyword to a method definition is equal to the entire method body being wrapped in a synchronized code block with the lock object being this  for instance methods  and ClassInQuestion getClass    for class methods    - Instance method is a method which does not have static keyword  - Class method is a method which has static keyword   Technical  Without synchronization  it is not guaranteed in which order the reads and writes happen  possibly leaving the variable with garbage   For example a variable could end up with half of the bits written by one thread and half of the bits written by another thread  leaving the variable in a state that neither of the threads tried to write  but a combined mess of both    It is not enough to complete a write operation in a thread before  wall-clock time  another thread reads it  because hardware could have cached the value of the variable  and the reading thread would see the cached value instead of what was written to it   Conclusion  Thus in Java s case  you have to follow the Java Memory Model to ensure that threading errors do not happen  In other words  Use synchronization  atomic operations or classes that use them for you under the hoods      Sources      http   docs oracle com javase specs jls se8 html index html   Java   Language Specification  2015-02-13

User · Answer

Synchronized normal method equivalent to Synchronized statement  use this   class A       public synchronized void methodA                all function code            equivalent to      public void methodA             synchronized this                    all function code                      Synchronized static method equivalent to Synchronized statement  use class   class A       public static synchronized void methodA                all function code            equivalent to      public void methodA             synchronized A class                    all function code                      Synchronized statement  using variable   class A       private Object lock1   new Object         public void methodA             synchronized lock1                     all function code                      For synchronized  we have both Synchronized Methods and Synchronized Statements  However  Synchronized Methods is similar to Synchronized Statements so we just need to understand Synchronized Statements      Basically  we will have  synchronized object or class       object class use to provides the intrinsic lock       code      Here is 2 think that help understanding synchronized   Every object class have an intrinsic lock associated with it  When a thread invokes a synchronized statement  it automatically acquires the intrinsic lock for that synchronized statement s object and releases it when the method returns  As long as a thread owns an intrinsic lock  NO other thread can acquire the SAME lock    thread safe        When a thread A invokes synchronized this     code 1     all the block code  inside class  where have synchronized this  and all synchronized normal method  inside class  is locked because SAME lock  It will execute after thread A unlock      code 1  finished      This behavior is similar to synchronized a variable     code 1  or synchronized class      SAME LOCK    lock  not depend on which method  or which statements    Use synchronized method or synchronized statements   I prefer synchronized statements because it is more extendable  Example  in future  you only need synchronized a part of method  Example  you have 2 synchronized method and it don t have any relevant to each other  however when a thread run a method  it will block the other method  it can prevent by use synchronized a variable       However  apply synchronized method is simple and the code look simple  For some class  there only 1 synchronized method  or all synchronized methods in the class in relevant to each other    we can use synchronized method to make code shorter and easy to understand  Note   it not relevant to much to synchronized  it is the different between object and class or none-static and static      When you use synchronized or normal method or synchronized this  or synchronized non-static variable  it will synchronized base on each object instance    When you use synchronized or static method or synchronized class  or synchronized static variable  it will synchronized base on class   Reference  https   docs oracle com javase tutorial essential concurrency syncmeth html https   docs oracle com javase tutorial essential concurrency locksync html  Hope it help

User · Answer

The synchronized keyword is all about different threads reading and writing to the same variables  objects and resources   This is not a trivial topic in Java  but here is a quote from Sun      synchronized methods enable a simple   strategy for preventing thread   interference and memory consistency   errors  if an object is visible to   more than one thread  all reads or   writes to that object s variables are   done through synchronized methods    In a very  very small nutshell  When you have two threads that are reading and writing to the same  resource   say a variable named foo  you need to ensure that these threads access the variable in an atomic way   Without the synchronized keyword  your thread 1 may not see the change thread 2 made to foo  or worse  it may only be half changed   This would not be what you logically expect   Again  this is a non-trivial topic in Java   To learn more  explore topics here on SO and the Interwebs  about    Concurrency Java Memory Model   Keep exploring these topics until the name  Brian Goetz  becomes permanently associated with the term  concurrency  in your brain

User · Answer

In java to prevent multiple threads manipulating a shared variable we use synchronized keyword  Lets understand it with help of the following example  In the example I have defined two threads and named them increment and decrement  Increment thread increases the value of shared variable  counter  by the same amount the decrement thread decreases it i e 5000 times it is increased  which result in 5000   0   5000  and 5000 times we decrease  which result in 5000 - 5000   0   Program without synchronized keyword  class SynchronizationDemo        public static void main String   args            Buffer buffer   new Buffer                                MyThread incThread   new MyThread buffer   quot increment quot            MyThread decThread   new MyThread buffer   quot decrement quot              incThread start            decThread start                      try             incThread join              decThread join             catch InterruptedException e              System out println  quot Final counter   quot  buffer getCounter              class Buffer       private int counter   0       public void inc     counter          public void dec     counter--         public int getCounter     return counter       class MyThread extends Thread        private String name      private Buffer buffer       public MyThread  Buffer aBuffer  String aName                        buffer   aBuffer           name   aName              public void run            for  int i   0  i  lt   5000  i                 if  name equals  quot increment quot                    buffer inc                else                 buffer dec                                                  If we run the above program we expect value of buffer to be same since incrementing and decrementing the buffer by same amount would result in initial value we started with right    Lets see the output   As you can see no matter how many times we run the program we get a different result reason being each thread manipulated the counter at the same time  If we could manage to let the one thread to first increment the shared variable and then second to decrement it or vice versa we will then get the right result that is exactly what can be done with synchronized keyword by just adding synchronized keyword before the inc and dec methods of Buffer like this  Program with synchronized keyword     rest of the code  class Buffer       private int counter   0          added synchronized keyword to let only one thread        be it inc or dec thread to manipulate data at a time     public synchronized void inc     counter          public synchronized void dec     counter--         public int getCounter     return counter          rest of the code  and the output   no matter how many times we run it we get the same output as 0

User · Answer

The synchronized keyword causes a thread to obtain a lock when entering the method  so that only one thread can execute the method at the same time  for the given object instance  unless it is a static method    This is frequently called making the class thread-safe  but I would say this is a euphemism  While it is true that synchronization protects the internal state of the Vector from getting corrupted  this does not usually help the user of Vector much    Consider this    if  vector isEmpty          vector add data        Even though the methods involved are synchronized  because they are being locked and unlocked individually  two unfortunately timed threads can create a vector with two elements   So in effect  you have to synchronize in your application code as well   Because method-level synchronization is a  expensive when you don t need it and b  insufficient when you need synchronization  there are now un-synchronized replacements  ArrayList in the case of Vector    More recently  the concurrency package has been released  with a number of clever utilities that take care of multi-threading issues

User · Answer

What the other answers are missing is one important aspect  memory barriers  Thread synchronization basically consists of two parts  serialization and visibility  I advise everyone to google for  jvm memory barrier   as it is a non-trivial and extremely important topic  if you modify shared data accessed by multiple threads   Having done that  I advise looking at java util concurrent package s classes that help to avoid using explicit synchronization  which in turn helps keeping programs simple and efficient  maybe even preventing deadlocks   One such example is ConcurrentLinkedDeque  Together with the command pattern it allows to create highly efficient worker threads by stuffing the commands into the concurrent queue -- no explicit synchronization needed  no deadlocks possible  no explicit sleep   necessary  just poll the queue by calling take     In short   memory synchronization  happens implicitly when you start a thread  a thread ends  you read a volatile variable  you unlock a monitor  leave a synchronized block function  etc  This  synchronization  affects  in a sense  flushes   all writes done before that particular action  In the case of the aforementioned ConcurrentLinkedDeque  the documentation  says       Memory consistency effects  As with other concurrent collections    actions in a thread prior to placing an object into a   ConcurrentLinkedDeque happen-before actions subsequent to the access   or removal of that element from the ConcurrentLinkedDeque in another   thread    This implicit behavior is a somewhat pernicious aspect because most Java programmers without much experience will just take a lot as given because of it  And then suddenly stumble over this thread after Java isn t doing what it is  supposed  to do in production where there is a different work load -- and it s pretty hard to test concurrency issues

User · Answer

synchronized means that in a multi threaded environment  an object having  synchronized method s  block s  does not let two threads to access the synchronized method s  block s  of code at the same time  This means that one thread can t read while another thread updates it   The second thread will instead wait until the first thread completes its execution  The overhead is speed  but the advantage is guaranteed consistency of data   If your application is single threaded though  synchronized blocks does not provide benefits

User · Answer

The synchronized keyword prevents concurrent access to a block of code or object by multiple threads  All the methods of Hashtable are synchronized  so only one thread can execute any of them at a time     When using non-synchronized constructs like HashMap  you must build thread-safety features in your code to prevent consistency errors

User · Answer

To my understanding synchronized basically means that the compiler write a monitor enter and monitor exit around your method  As such it may be thread safe depending on how it is used  what I mean is you can write an object with synchronized methods that isn t threadsafe depending on what your class does

User · Answer

Well  I think we had enough of theoretical explanations  so consider this code  public class SOP       public static void print String s            System out println s   n             public class TestThread extends Thread       String name      TheDemo theDemo      public TestThread String name TheDemo theDemo            this theDemo   theDemo          this name   name          start               Override     public void run             theDemo test name            public class TheDemo       public synchronized void test String name            for int i 0 i lt 10 i                  SOP print name          i               try                  Thread sleep 500                 catch  Exception e                    SOP print e getMessage                                       public static void main String   args            TheDemo theDemo   new TheDemo            new TestThread  THREAD 1  theDemo           new TestThread  THREAD 2  theDemo           new TestThread  THREAD 3  theDemo             Note  synchronized blocks the next thread s call to method test   as long as the previous thread s execution is not finished  Threads can access this method one at a time  Without synchronized all threads can access this method simultaneously   When a thread calls the synchronized method  test  of the object  here object is an instance of  TheDemo  class  it acquires the lock of that object  any new thread cannot call ANY synchronized method of the same object as long as previous thread which had acquired the lock does not release the lock   Similar thing happens when any static synchronized method of the class is called  The thread acquires the lock associated with the class in this case any non static synchronized method of an instance of that class can be called by any thread because that object level lock is still available   Any other thread will not be able to call any static synchronized method of the class as long as the class level lock is not released by the thread which currently holds the lock   Output with synchronised  THREAD 1    0 THREAD 1    1 THREAD 1    2 THREAD 1    3 THREAD 1    4 THREAD 1    5 THREAD 1    6 THREAD 1    7 THREAD 1    8 THREAD 1    9 THREAD 3    0 THREAD 3    1 THREAD 3    2 THREAD 3    3 THREAD 3    4 THREAD 3    5 THREAD 3    6 THREAD 3    7 THREAD 3    8 THREAD 3    9 THREAD 2    0 THREAD 2    1 THREAD 2    2 THREAD 2    3 THREAD 2    4 THREAD 2    5 THREAD 2    6 THREAD 2    7 THREAD 2    8 THREAD 2    9   Output without synchronized  THREAD 1    0 THREAD 2    0 THREAD 3    0 THREAD 1    1 THREAD 2    1 THREAD 3    1 THREAD 1    2 THREAD 2    2 THREAD 3    2 THREAD 1    3 THREAD 2    3 THREAD 3    3 THREAD 1    4 THREAD 2    4 THREAD 3    4 THREAD 1    5 THREAD 2    5 THREAD 3    5 THREAD 1    6 THREAD 2    6 THREAD 3    6 THREAD 1    7 THREAD 2    7 THREAD 3    7 THREAD 1    8 THREAD 2    8 THREAD 3    8 THREAD 1    9 THREAD 2    9 THREAD 3    9

User · Answer

Here is an explanation from The Java Tutorials   Consider the following code    public class SynchronizedCounter       private int c   0       public synchronized void increment             c               public synchronized void decrement             c--             public synchronized int value             return c                if count is an instance of SynchronizedCounter  then making these methods synchronized has two effects          First  it is not possible for two invocations of synchronized methods on the same object to interleave  When one thread is executing a synchronized method for an object  all other threads that invoke synchronized methods for the same object block  suspend execution  until the first thread is done with the object    Second  when a synchronized method exits  it automatically establishes a happens-before relationship with any subsequent invocation of a synchronized method for the same object  This guarantees that changes to the state of the object are visible to all threads

[java] What does 'synchronized' mean?

Examples related to java

Examples related to multithreading

Examples related to keyword

Examples related to synchronized