Question

我有一个问题要理解Java中的锁和条件，我不明白为什么我的代码最终陷入死锁。
我的程序由Mainthread和Subthread组成，subthread是Mainthread的成员。两个线程都在无限循环中运行，Subthread的循环应该在从Mainthread接收到startCond的信号后立即执行一次迭代。 Mainthread应该等待finishCond信号继续。

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockTest {

    public static void main(String[] args) {
        LockTest lt = new LockTest();
        Mainthread m1 = lt.new Mainthread();
        m1.start();
    }

    public class Mainthread extends Thread {
        private Subthread sub = new Subthread();

        public void run(){
            System.out.println("Main start");
            sub.start();

            while(!isInterrupted()) {
                try {
                    sub.getStartLock().lock();
                    sub.getStartCond().signal();
                    sub.getStartLock().unlock();

                    sub.getFinishLock().lock();
                    sub.getFinishCond().await();
                    sub.getFinishLock().unlock();
                    System.out.println("Main done");
                } catch(InterruptedException e) {
                    e.printStackTrace();
                }

            }   
        }
    }

    public class Subthread extends Thread {
        private Lock startLock = new ReentrantLock();
        private Lock finishLock = new ReentrantLock();
        private Condition startCond = startLock.newCondition();
        private Condition finishCond = finishLock.newCondition();


        public Lock getStartLock() {
            return startLock;
        }

        public Lock getFinishLock() {
            return finishLock;
        }

        public Condition getStartCond() {
            return startCond;
        }

        public Condition getFinishCond() {
            return finishCond;
        }

        public void run() {
            System.out.println("Sub start");
            while(!isInterrupted()) {
                try {
                    startLock.lock();
                    startCond.await();
                    startLock.unlock();

                    finishLock.lock();
                    finishCond.signal();
                    finishLock.unlock();

                    System.out.println("Sub done");
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
}

我的预期输出是：
主要完成了
（重复在循环中执行的次数）。

有没有办法更容易解决这个问题？

Answer 1

主线程启动，它创建新的子线程并启动它但是在线程上调用start并不意味着该线程将接收处理器imeddiatly并且其代码将被实际执行。

Main，callss sub.getStartCond（）。signal（）;但是此时子线程仍未运行，因此它错过了这个信号。

Main，等待在finishCond上。

Sub开始执行其run方法，它进入启动条件并等待它永远。

僵局。

信号仅唤醒当前正在等待的线程，它不会“记住”之前的呼叫。

使用信号量而不是http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Semaphore.html

它具有“计算许可证”的语义。

Answer 2

可能有更可靠的方法来做到这一点。我建议使用初始化为{1}的CountDownLatch而不是条件。主线程和子线程都可以共享锁存器的相同实例（因为主要拥有应该很容易的子节点）。当您需要向孩子发送信号时，孩子会拨打await()，主人会拨打countDown()。我建议您设置锁定private和final。

class ChildThread extends Thread {
  private final CountDownLatch signal;

  public ChildThread(CountDownLatch signal) {
    this.signal = signal;
  }

  public void run() {
    // The loop is necessary in case we get interrupted.
    while (true) {
      try {
        signal.await();
        break;
      } catch(InterruptedException ignored) {
      }
    }
    // do the work...
  }
}

class MainThread extends Thread {
  private final ChildThread child;
  private final CountDownLatch signalToChild;
  public MainThread() {
    signalToChild = new CountDownLatch(1);
    child = new ChildThread(signalToChild);
  }

  public void run() {
    // I can start the child right away but I'd rather make sure it
    // starts if the main thread has started.
    child.start();
    // prework
    // let's signal the child
    signalToChild.countDown();
    // now the child is working, let's go on with the main thread work
  }
}

这是有效的，因为主线程和子线程实际上共享状态，即锁存器。如果主线程在子线程实际启动之前递减锁存器并不重要，因为子进程将检查此共享状态以确定它是否可以启动。

与锁和条件的线程同步

2 个答案: