CODEWITHSUNDEEP
javasynchronization
Madhu
Madhu

Reputation: 5756

Disadvantage of synchronized methods in Java

What are the disadvantages of making a large Java non-static method synchronized? Large method in the sense it will take 1 to 2 mins to complete the execution.

Upvotes: 3

Views: 18157

Answers (7)

Yash Patel
Yash Patel

Reputation: 1

First drawback is that threads that are blocked waiting to execute synchronize code can't be interrupted.Once they're blocked their stuck there, until they get the lock for the object the code is synchronizing on.

Second drawback is that the synchronized block must be within the same method in other words we can't start a synchronized block in one method and end the syncronized block in another for obvious reasons.

The third drawback is that we can't test to see if an object's intrinsic lock is available or find out any other information about the lock also if the lock isn't available we can't timeout after we waited lock for a while. When we reach the beginning of a synchronized block we can either get the lock and continue executing or block at that line of code until we get the lock.

The fourth drawback is that if multiple threads are awaiting to get lock, it's not first come first served. There isn't set order in which the JVM will choose the next thread that gets the lock, so the first thread that blocked could be the last thread to get the lock and vice Versa.

so instead of using synchronization we can prevent thread interference using classes that implement the java.util.concurrent locks.lock interface.

Upvotes: 0

Swapnil G Thaware
Swapnil G Thaware

Reputation: 877

In simple two lines Disadvantage of synchronized methods in Java :

 1. Increase the waiting time of the thread
 2. Create a performance problem

Upvotes: -1

user10314212
user10314212

Reputation:

In simple two lines Disadvantage of synchronized methods in Java :

  1. Increase the waiting time of the thread
  2. Create performance problem

Upvotes: 0

Thilo
Thilo

Reputation: 262474

If you synchronize the method and try to call it twice at the same time, one thread will have to wait two minutes.

This is not really a question of "disadvantages". Synchronization is either necessary or not, depending on what the method does.

If it is critical that the code runs only once at the same time, then you need synchronization.

If you want to run the code only once at the same time to preserve system resources, you may want to consider a counting Semaphore, which gives more flexibility (such as being able to configure the number of concurrent executions).

Another interesting aspect is that synchronization can only really be used to control access to resources within the same JVM. If you have more than one JVM and need to synchronize access to a shared file system or database, the synchronized keyword is not at all sufficient. You will need to get an external (global) lock for that.

Upvotes: 18

Peter Recore
Peter Recore

Reputation: 14187

Since your method takes a huge amount of time to run, the relatively tiny amount of time it takes to acquire the synchronized lock should not be important.

A bigger problem could appear if your program is multithreaded (which I'm assuming it is, since you're making the method synchronized), and more than one thread needs to access that method, it could become a bottleneck. To prevent this, you might be able to rewrite the method so that it does not require synchronization, or use a synchronized block to reduce the size of the protected code (in general, the smaller the amount of code that is protected by the synchronize keyword, the better).

You can also look at the java.util.concurrent classes, as you may find a better solution there as well.

Upvotes: 2

user57368
user57368

Reputation: 5765

If the method takes on the order of minutes to execute, then it may not need to be synchronized at such a coarse level, and it may be possible to use a more fine-grained system, perhaps by locking only the portion of a data structure that the method is operating on at the moment. Certainly, you should try to make sure that your critical section isn't really 2 minutes long - any method that takes that long to execute (regardless of the presence of other threads or locks) should be carefully studied as a candidate for parallelization. For a computation this time-consuming, you could be acquiring and releasing hundreds of locks and still have it be negligible. (Or, to put it another way, even if you need to introduce a lot of locks to parallelize this code, the overhead probably won't be significant.)

Upvotes: 4

Stephen C
Stephen C

Reputation: 718698

If the object is shared by multiple threads, if one thread tries to call the synchronized method on the object while another's call is in progress, it will be blocked for 1 to 2 minutes. In the worst case, you could end up with a bottleneck where the throughput of your system is dominated by executing these computations one at a time.

Whether this is a problem or not depends on the details of your application, but you probably should look at more fine-grained synchronization ... if that is practical.

Upvotes: 1

Related Questions