Atomic thread safe integer increment..

[lordy]

Hi, I want to keep a running 'int' total across threads but without the
'synchronized' overhead. (This total will be spinning pretty fast).

I'm guessing Most processors have some kind of atomic (and hopefully) thread safe increment command.
However a big of Googling suggests this may be possible in Java 1.5 but
not in Java 1.4.2 ('Twas an IBM article http://www-128.ibm.com/developerworks/java/library/j-jtp11234/)

I guess the most performant(?) option is to maintain separate totals and
combine them at report time?

Lordy

 

[Thomas Kellerer]

Hi, I want to keep a running 'int' total across threads but without the
'synchronized' overhead. (This total will be spinning pretty fast).

I'm guessing Most processors have some kind of atomic (and hopefully) thread safe increment command.
However a big of Googling suggests this may be possible in Java 1.5 but
not in Java 1.4.2 ('Twas an IBM article http://www-128.ibm.com/developerworks/java/library/j-jtp11234/)

I guess the most performant(?) option is to maintain separate totals and
combine them at report time?

The perfomance "penalty" of a synchronized block is relatively small.

I think there is an article on DeveloperWorks that de-mystifies the
common believe that synchronize will make things slower. If I recall the
article correctly this was true for JDK up to 1.3 but starting with 1.4
(or 1.5 not 100% sure about that) the overhead is so small that it does
not justify the effort to avoid it.

Thomas

 

[Thomas Hawtin]

The perfomance "penalty" of a synchronized block is relatively small.

I think there is an article on DeveloperWorks that de-mystifies the
common believe that synchronize will make things slower. If I recall the
article correctly this was true for JDK up to 1.3 but starting with 1.4
(or 1.5 not 100% sure about that) the overhead is so small that it does
not justify the effort to avoid it.

If it's a contended lock, particularly on a multicore machine, it could
well be a problem. Having said that, in this case the lock shouldn't be
held for very long.

A local value for each thread should be much faster. Alternatively, if
you can live with an inaccurate variable, just use volatile (I think
that works in 1.4).

Tom Hawtin

 

[Patricia Shanahan]

The perfomance "penalty" of a synchronized block is relatively small.

I think there is an article on DeveloperWorks that de-mystifies the
common believe that synchronize will make things slower. If I recall the
article correctly this was true for JDK up to 1.3 but starting with 1.4
(or 1.5 not 100% sure about that) the overhead is so small that it does
not justify the effort to avoid it.

....

There is an inherent cost to synchronization in forcing threads to run
serially rather than in parallel, but you would have to be doing a
simple integer increment very, very frequently relative to other work
before that would be a problem.

The usual advice, start simple and optimize if necessary, applies.

Patricia