Synchronizing threads in java

Good day! I got the problem about sync开发者_StackOverflow中文版hronizing threads in java. I am developing program which creates timers and allows to reset it, delete and stop. Just to learn how to using threads.

The problem is that code gives synchronizing only for some time... I can't understand my mistake. Maybe my way is wrong so i would like to know how to solve this issue.

I have next code:

public class StopWatch
{
    //Create and start our timer
    public synchronized void startClock( final int id )
    {                                 
            //Creating new thread.
            thisThread = new Thread()
            {
                @Override
                 public void run()
                 {
                    try
                    {                                               
                        while( true )
                        {
                            System.out.printf( "Thread [%d] = %d\n", id, timerTime );
                            timerTime  += DELAY;                                        //Count 100 ms
                            Thread.sleep( DELAY );                                      
                        }
                    }
                    catch( InterruptedException ex )
                    {
                        ex.printStackTrace();
                    }
                 }
            };

            thisThread.start();           
    }

…
   //Starting value of timer
   private long timerTime = 0;
   //Number of ms to add and sleep                                      
   private static final int DELAY    = 100;                                  

    private Thread thisThread;
} 

I call this Class like:

StopWatch s = new StopWatch(1);
          s.startClock();
StopWatch s2 = new StopWatch(2);
          s2.startClock();

I think you may have misunderstood "synchronized".

It does not mean that the threads run in exactly synchronized time - rather that only one thread at a time is allowed to be executing the synchronized code block. In your case "synchronized" makes no difference, since you are calling the startClock method from the same thread....

In general, it is impossible in Java (and indeed most high level languages) to guarantee that two threads perform actions at exactly the same clock time even if you have multiple cores, since they are always vulnerable to being delayed by the OS scheduler or JVM garbage collection pauses etc.

Also, Thread.sleep(...) is unreliable as a timing mechanism, as the amount it sleeps for is only approximate. You're at the mercy of the thread scheduler.

Suggested solution:

use System.currentTimeMillis() if you want a thread-independent timing mechansim.

What do you mean it "only gives you synchronizing for some time?" The only thing you have synchronized here is the startClock method, which just means that two threads will not be within that method at the same time (and it doesn't look like you are doing that anyway). If you wanted to synchronize access to timerTime for example, you would need to put a synchronized block inside thread run method around the incrementing timerTime (or you could use an AtomicLong).

You should probably re-read the documentation for the "synchronize" keyword. I'm pretty sure in this case all it would do is keep the two calls of StartClock() from executing at the same time, which wouldn't happen given this code because they're called one after the other from one thread. Once the timer thread begins, there's nothing keeping them synchronized, if that's your goal.

Your first problem is that this is a time based only solution. This is bad because the program has no control over how long it takes to execute. Some operations take more time than others and each thread within your process doesn't execute at the same time. In general this won't synchronize anything unless you can guarantee everything else is the same . . .

Read about http://download.oracle.com/javase/6/docs/api/java/util/concurrent/Semaphore.html and you can also do

Thread.join(); to make the main loop wait for the execution of the child thread to finish before continuing execution.

I think you misunderstood what synchronized means. Synchronized is to ensure that multiple threads have limited access to a certain block of code so that you don't get conflicts between the two threads.

I think what you may be more interested in is a CyclicBarrier or a CountDownLatch. Both can be used to "synchronize" (overloaded use in this case) multiple threads so that they try to start doing things at the same time.

However, be aware that it's impossible to have multiple threads do things at exactly the same instant. You can only try to encourage to do them at about the same time. The rest is subject to OS scheduling on the cores in the system. And if you have a single core, they will never run at the same time.