Threads behaving wierdly..Work of 5 months going for a toss.. plz help...?

Question

Hi everyone,
I am stuck into this probel very badly..i have never seen such a problem before..Thread bottleneck somewhere is the issue i guess,,, plz have a look at the code patiently.. and do reply.. u guys are my last hope on this thing..Thank YOU...
The Bank method is called by another method which runs 50 threads , so
at a time 50 threads could enter this method to record Debit... class BankHelper {
// Some code of bank.. not relevant to my problem
     public Bank() {
                long time = System.nanoTime();
                abc.recordDebit();_ *// want to measure how much time this method takes*_
                abc.recordTimeForDebit(System.nanoTime() - time); *_// accumulating the total time the above method takes to calculate_*
    class abc {
// Some code of bank.. not relevant to my problem
    public synchronized void recordDebit(){
        debit++;      
    } _*// I had put timers aound the ++ and it took not more than 700 to 900 nanoseconds*_
    public synchronized void recordTimeForDebit(long time){
        record += time;
        Log.debug("Time taken to record drop for DEBIT " + record + " Millis " + time);
Answer:_
Record time is 9014 millis for 5000 increments or 5000 calls to recordDebit()_
One can see in the answer that its a huge number when one is expecting it to be somewhere around:
EXPECTED ANSWER:
*5000 * 800 nanos( it takes 800 nanos for very increment) = 4000000 = 4 millis and its like 9014 millis*
How is there such a huge difference ????????? I have bruised thorugh it for like 3 days... i have lost all my hope.. Plz help..Also look at the next code..
When i go to see in the log .. it shows me that every record took like from 2000 nanos to 6 to 7 millis i.e.7000000...
HOw is this even possibly possible ??? where did it get all this extra time from...it should not be more than some 700 to 900 nanos ..
Is there a bottleneck somewhere ????
Now part 2:
This thing has fazzed, dazzled , destroyed me.. I could not understand this and it has tossed all my concepts into the cupboard..
Same stuff: JUST HAVE A LOOK AND ENJOY AND TELL ME WHATS GOING ON...Same code.. different way of incrementing data i.e synchronization is at a different place..but results are very highly improved...
    class BankHelper {
// Some code of bank.. not relevant to my problem
     public Bank() {
                long time = System.nanoTime();
                abc.recordDebit(); // want to measure how much time this method takes
                abc.recordTimeForDebit(System.nanoTime() - time); // accumulating the total time the above method takes to calculate
}The Bank method is called by another method which runs 50 threads , so at a time 50 threads could enter this method to record Debit...
    class abc {
// Some code of bank.. not relevant to my problem
    public void recordDebit(){
        someotherclass.increment();      
    } // this is not synchronized nowwwwwwww
// I have put timers here too and it took like 1500 to 2500 nanos
    public synchronized void recordTimeForDebit(long time){
        record += time;
        Log.debug("Time taken to record drop for DEBIT " + record + " Millis " + time);
class someotherclass{
// Not relevant code
    public void increment(){
        someotherclass1.increment1();      
class someotherclass1{
// Not relevant code
    public void increment1(){
        someotherclass2.increment2();      
class someotherclass2{
// Not relevant code
    public synchronized void increment2(){
        someotherclass3.increment3();      
    } //now its synchronized
class someotherclass3{
// Not relevat code
    public synchronized void increment3(){
        debit++;      
    } //now its synchronized
ANSWER: Record is 135 millis for 5000 increments or 5000 calls to recordDebit()_
Expected time was : 5000 2500 = 125000000 = 125 millis (WOW .. AS EXPECTED)*
Please don't ask me why this code has been written this way..i know it goes and increment and does the same thing...but somehow when i measured it..
overall time or the accumulated time for both codes varied like in huge numbers...even though latter code is actually a superset of previous code..
HOW IS THERE SUCH A HUGE DIFFERENCE BETWEEN THE NUMBERS ???
COULD BE BECAUSE OF THE POINT OF SYNCHRONIZATION ???
Thank you..for going through all this..

Answer 1

Answered on JavaRanch. By synchronizing both the increment and the recording methods, you can only perform one of those functions at a time.Thanking you Steve, I shall read and inwardly digest.
My (humble) advise is:
1. WTF are you doing trying to measure the time taken to execute a [unirary operation|http://en.wikipedia.org/wiki/Unary_operation] (you putz!) which is just like so freeken small (on a 2Ghz CPU) that even a gazzillion invocations might take less time than it took you get your duds off in order to earn your reputation as a putz!
2. FFS, Don't write profiling code in your app... just download one. VisualVM is way cool!
3. As you would know, if you had bothered to actually RTFM at any stage in your (bugging;-) career... synchronized methods are slow(er) because of the farckin time taken to acquire and release the lock... as well as the inherent inefficiency of bottlenecking a whole method, as apposed to just the critical statements... which in the case of a simple incrementor is just about no near new never mind... so no never mind... but still the fact remains... you've turned an atomic operation (google it yourself) into a bottleneck... and then you're standing there whining about bottlenecks. Doh!
4. Seriously dude, read the effin manual.
Edited by: corlettk on 27/09/2008 14:19