'synchronized' method problem

Question

Hi, I want to listen to your opinion on using 'synchronized' on
a huge method. I know it will degrade performance alot. However, in some cases it may be inevitable using 'synchrnoized' keyword on big method. Of course, there is 'synchronized' block also available in Java, but it is not a solution in some cases. For example, in below code
interface Condition {
boolean isCorrect();
class Foo {
int value = 0;
void addCondtition(Condition c) ;
synchronized boolean increaseCount(int quantity)
//loop through all added Conditions and executes each
Condition's isCorrect();
//if all Conditions are true then increase value as much as the
received quantity
In above example, while checking all added conditions, it is possible
the 'value' is updated by other threads in multi-threaded program by calling increaseCount. Also, if added Conditions are refering to the 'value' to determine, then the 'value' should not be updated in the middle of Condition checking process.
Solution to protect 'value' from other thead is 'synchronized' on increaseCount. I can't come up any other solution. But problem is
since multiple Conditions can be added, execution time of the increaseCount method can significantly increased.
Does anyone have better solution to avoid 'synchronized' on such a huge method?

Answer 1

Hi, I want to listen to your opinion on using
'synchronized' on
a huge method. I know it will degrade performance
alot. That's a rather common, unfounded and generally inaccurate assumption you've got there. It's true that it will adversely affect performance but not necessarily by "a lot".
However, in some cases it may be inevitable
using 'synchrnoized' keyword on big method. Of
course, there is 'synchronized' block also available
in Java, but it is not a solution in some casesThat's technically not true, but I understand what you mean.
. For
example, in below code
interface Condition {
boolean isCorrect();
lass Foo {
int value = 0;
void addCondtition(Condition c) ;
synchronized boolean increaseCount(int quantity)
//loop through all added Conditions and
executes each
Condition's isCorrect();
/if all Conditions are true then increase value as
much as the
received quantity
In above example, while checking all added
conditions, it is possible
the 'value' is updated by other threads in
multi-threaded program by calling increaseCount.
Also, if added Conditions are refering to the 'value'
to determine, then the 'value' should not be updated
in the middle of Condition checking process.
Solution to protect 'value' from other thead is
'synchronized' on increaseCount. I can't come up any
other solution. But problem is
since multiple Conditions can be added, execution
time of the increaseCount method can significantly
increased.
Does anyone have better solution to avoid
'synchronized' on such a huge method?In your example there isn't an obvious alternative. Refactoring your design might create some opportunities. Perhaps you'd be better served by explaining to us what you're hoping to achieve rather than trying to discuss one specific method's implementation.