Syncronisize两个循环Java-Thread

Question

Two threads are running parallel:

Thread1:

while(...) {
  <-- wait until thread2 is not in update()
  doWork();
}

Thread2:

while(...) {
  doWork();
  <-- wait until thread1 is not in work()
  update();
}

I think the examples above explain what I try to do, but I have not really an idea how to do this synchronization. The update() -method of thread2 is critical an while it is executed thread2 have to wait.

Edit:

Thanks so far for the answers. More than one is working well. I was asked what I am trying to do and I want to give an short update for that.

Based on the currentState thread2 calculates the nextState and swap both before it repeats calculating endless. thread1 displays the 'currentState' in the gui for the user.

Thread1 should not display the currentState while the swaping is currently in progress.

Thats all.

Answer 1

Using a Lock would be the easiest approach. Here's a demo of how simple it is. We create two Runnable and start them running under two threads. We then wait for 30 seconds and then interrupt them and wait for them to finish.

// Lock shared between both threads.
final Lock lock = new ReentrantLock();
// Random numbers.
final Random random = new Random();

public void test() throws InterruptedException {
    // Process 1 is a runnable.
    Runnable p1 = new Runnable() {

        @Override
        public void run() {
            while (true) {
                try {
                    // Grab the lock.
                    lock.lock();
                    // Do my work.
                    doWork();
                } catch (InterruptedException ex) {
                    System.out.println("P1 Interrupted!");
                    break;
                } finally {
                    // Release the lock in a `finally` to ensure it can never be left locked.
                    lock.unlock();
                }
            }
        }

        private void doWork() throws InterruptedException {
            long wait = random.nextInt(2000);
            System.out.println("P1 Working ... " + wait);
            // Wait up to 2 seconds.
            Thread.sleep(wait);
            System.out.println("P1 Work done");
        }

    };

    Runnable p2 = new Runnable() {

        @Override
        public void run() {
            while (true) {
                try {
                    // Do my work.
                    doWork();
                    // Grab the lock.
                    lock.lock();
                    // Do my update.
                    update();
                } catch (InterruptedException ex) {
                    System.out.println("P2 Interrupted!");
                    break;
                } finally {
                    lock.unlock();
                }
            }
        }

        private void doWork() throws InterruptedException {
            long wait = random.nextInt(2000);
            System.out.println("P2 Working ... " + wait);
            // Wait up to 2 seconds.
            Thread.sleep(wait);
            System.out.println("P2 Work done");
        }

        private void update() throws InterruptedException {
            long wait = random.nextInt(2000);
            System.out.println("P2 Update ... " + wait);
            // Wait up to 2 seconds.
            Thread.sleep(wait);
            System.out.println("P2 Update done");
        }

    };

    // Create the two threads.
    Thread t1 = new Thread(p1);
    Thread t2 = new Thread(p2);
    // Start them up.
    t1.start();
    t2.start();
    // Wait 30 seconds - with narrative.
    for (int i = 0; i < 30; i++) {
        Thread.sleep(1000);
        System.out.println("Tick");

    }
    // Stop them.
    t1.interrupt();
    t2.interrupt();
    // Wait for them to stop.
    t1.join();
    t2.join();

}

Running this should demonstrate one of the problems with your design. Notice that the P2 Update rarely gets called. This is because P1 spends very little time with the lock released and so starves the other thread. See how in p1 it will lock.unlock() and then almost immediately do a lock.lock() again as it starts the loop again.

Answer 2

One way would be to use locks (look at the java.util.concurrent.locks package) but I'd first think about whether the approach in general could be improved, eg with lock-free algorithms etc.

Another way could be the use of synchronized methods/blocks on a shared object. That all depends on what you're actually trying to achieve, however.

Example for using a synchronized block:

T1:

while(...) {
  synchronized( SomeClass.class ) {
    doWork();
  }
}

T2:

while(...) {
  doWork();
  synchronized( SomeClass.class ) {
    update();
  }
}

Here you'd synchronize on the same instance of Class<SomeClass> which would work as long you're using the same classloader.

Keep in mind that you should make the synchronized blocks as small as possible in order to not add unnecessary blocking.

Besides that, note that the synchronized block in T1 might make it hard for T2 to break in between two iterations. The question, however, would be why it is designed that way.

Edit

As an alternative to synchronizing the entire doWork() call you might want to think about what actually needs to be synchronized.

As an example, take the following pseudo code:

  WorkResult doWork(SharedObject so) {
    Data data = so.loadData();
    WorkResult wr = doSomeLengthyWork(data);
    return wr;
  }

  void update(WorkResult wr, SharedObject so) {
    so.updateFromWorkResult( wr );
  }

If your situation is like this, you could just synchronize the calls to so.loadData() and so.updateFromWorkResult() and let the lengthy operation work on a copy of the data provided by so.loadData() .

Edit 2:

Alternatively you could use a ReadWriteLock implementation:

T1:

while(...) {
  Lock readlock = readWriteLock.readLock();
  readlock.lock();

  doWork();

  readlock.unlock();  
}

T2:

while(...) {
  doWork();

  Lock writelock= readWriteLock.writeLock();
  writelock.lock();

  update();

  writelock.unlock();
}

Note that I left exception handling etc. out for simplicity.

What you're basically doing here is aquire a read lock during work and a write lock while updating. Multiple threads can work in parallel unless there's a write lock (multiple read locks are allowed) and updates would wait until all read locks have been released. To achieve this you could use a ReentrantReadWriteLock in fair mode which should issue the locks in the order they are requested, ie when T2 asks for a lock while T1 is still reading it will get the lock next, despite T1 immediately asking for the lock again.

Answer 3

It's a pseudocode, really, but I hope the idea is understandable.

ExecutorService es = ...;
Future t1work = new Future(...);
Future t2work = new Future(...);
Future t2update = new Future(...);

es.submit(t1work);
es.submit(t2work);

while (1) {
  if (t1work.isDone() && t2work.isDone())   es.submit(t2update);
  if (t1work.isDone() && t2update.isDone()) es.submit(t1work);
  if (t2work.isDone() && t2update.isDone()) es.submit(t2work);
  Thread.sleep(100);
}