How do synchronized static methods work in Java and can I use it for loading Hibernate entities

Question

If I have a util class with static methods that will call Hibernate functions to accomplish basic data access  I am wondering if making the method synchronized is the right approach to ensure thread-safety   I want this to prevent access of info to the same DB instance  However  I m now sure if the following code are preventing getObjectById being called for all Classes when it is called by a particular class    public class Utils        public static synchronized Object getObjectById  Class objclass  Long id                  call hibernate class          Session session   new Configuration   configure   buildSessionFactory   openSession             Object obj   session load objclass  id            session close             return obj                  other static methods

User · Answer

If it is something to do with the data in your database  why not utilize database isolation locking to achieve

User · Answer

static synchronized means holding lock on the the class s Class object where as synchronized means holding lock on that class s object itself  That means  if you are accessing a non-static synchronized method in a thread  of execution  you still can access a static synchronized method using another thread    So  accessing two same kind of methods either two static or two non-static methods  at any point of time by more than a thread is not possible

User · Answer

Why do you want to enforce that only a single thread can access the DB at any one time    It is the job of the database driver to implement any necessary locking  assuming a Connection is only used by one thread at a time   Most likely  your database is perfectly capable of handling multiple  parallel access

User · Answer

By using synchronized on a static method lock you will synchronize the class methods and attributes   as opposed to instance methods and attributes   So your assumption is correct   I am wondering if making the method synchronized is the right approach to ensure thread-safety   Not really  You should let your RDBMS do that work instead  They are good at this kind of stuff  The only thing you will get by synchronizing the access to the database is to make your application terribly slow   Further more  in the code you posted you re building a Session Factory each time  that way  your application will spend more time accessing the DB than performing the actual job  Imagine the following scenario  Client A and B attempt to insert different information into record X of table T  With your approach the only thing you re getting is to make sure one is called after the other  when this would happen anyway in the DB  because the RDBMS will prevent them from inserting half information from A and half from B at the same time  The result will be the same but only 5 times   or more    slower  Probably it could be better to take a look at the  quot Transactions and Concurrency quot  chapter in the Hibernate documentation   Most of the times the problems you re trying to solve  have been solved already and a much better way

User · Answer

To answer your question  yes it does  your synchronized method cannot be executed by more than one thread at a time

User · Answer

Static methods use the class as the object for locking  which is Utils class for your example  So yes  it is OK

User · Answer

To address the question more generally     Keep in mind that using synchronized on methods is really just shorthand  assume class is SomeClass    synchronized static void foo                 is the same as  static void foo         synchronized SomeClass class                          and   synchronized void foo                 is the same as  void foo         synchronized this                          You can use any object as the lock  If you want to lock subsets of static methods  you can  class SomeClass       private static final Object LOCK 1   new Object           private static final Object LOCK 2   new Object           static void foo             synchronized LOCK 1                  static void fee             synchronized LOCK 1                  static void fie             synchronized LOCK 2                  static void fo             synchronized LOCK 2                   for non-static methods  you would want to make the locks be non-static fields

User · Answer

How the synchronized Java keyword works When you add the synchronized keyword to a static method  the method can only be called by a single thread at a time  In your case  every method call will   create a new SessionFactory create a new Session fetch the entity return the entity back to the caller  However  these were your requirements   I want this to prevent access to info to the same DB instance  preventing getObjectById being called for all classes when it is called by a particular class  So  even if the getObjectById method is thread-safe  the implementation is wrong  SessionFactory best practices The SessionFactory is thread-safe  and it s a very expensive object to create as it needs to parse the entity classes and build the internal entity metamodel representation  So  you shouldn t create the SessionFactory on every getObjectById method call  Instead  you should create a singleton instance for it  private static final SessionFactory sessionFactory   new Configuration        configure        buildSessionFactory     The Session should always be closed You didn t close the Session in a finally block  and this can leak database resources if an exception is thrown when loading the entity  According to the Session load method JavaDoc might throw a HibernateException if the entity cannot be found in the database   You should not use this method to determine if an instance exists  use get   instead   Use this only to retrieve an instance that you assume exists  where non-existence would be an actual error   That s why you need to use a finally block to close the Session  like this  public static synchronized Object getObjectById  Class objclass  Long id             Session session   null       try            session   sessionFactory openSession             return session load objclass  id          finally            if session    null                 session close                           Preventing multi-thread access In your case  you wanted to make sure only one thread gets access to that particular entity  But the synchronized keyword only prevents two threads from calling the getObjectById concurrently  If the two threads call this method one after the other  you will still have two threads using this entity  So  if you want to lock a given database object so no other thread can modify it  then you need to use database locks  The synchronized keyword only works in a single JVM  If you have multiple web nodes  this will not prevent multi-thread access across multiple JVMs  What you need to do is use LockModeType PESSIMISTIC READ or LockModeType PESSIMISTIC WRITE while applying the changes to the DB  like this  Session session   null  EntityTransaction tx   null   try       session   sessionFactory openSession             tx   session getTransaction        tx begin         Post post   session find          Post class           id           LockModeType LockModeType PESSIMISTIC READ             post setTitle  quot High-Performance Java Perisstence quot         tx commit      catch Exception e        LOGGER error  quot Post entity could not be changed quot   e       if tx    null            tx rollback             finally       if session    null            session close              So  this is what I did   I created a new EntityTransaction and started a new database transaction I loaded the Post entity while holding a lock on the associated database record I changed the Post entity and committed the transaction In the case of an Exception being thrown  I rolled back the transaction

[java] How do synchronized static methods work in Java and can I use it for loading Hibernate entities?

Examples related to java

Examples related to multithreading

Examples related to hibernate

Examples related to concurrency

Examples related to synchronization