Question

这是一个我遇到的奇怪情况。我有一个定义受保护字段的抽象基类。还有一种修改字段的公共方法。然后我有一些基类的子类使用该字段。

我注意到当我调用超类方法来修改字段时，对字段值的更改似乎并没有“贯彻”到子类的实例。

需要提及的另一件事是抽象类（及其子类）实现Runnable。我不认为这会对我所看到的情况产生影响，但多线程不是我的强项。

抽象基类：

public abstract class AbstractWidget implements Runnable {
  // Other fields and methods omitted for brevity.
  protected boolean running;

  public void shutDown() {
    running = false;
  }
}

子类：

public class ConcreteWidget extends AbstractWidget {
  // Other fields and methods omitted for brevity.

  @Override
  public void run() {
    running = true;
    while (running) {
      // ...
    }
    logger.info("Shutting down");
  }
}

因此，当我最终调用shutDown()方法时，在线程中运行的子类实例不会从它的循环中断并返回。

我使用了从“外部”修改布尔字段的技术，以便多次停止“永久”线程。我不明白这里发生了什么。

更新：

以下是被调用代码的示例。

ConcreteWidget widet = new ConcreteWidget(...);
thread = new Thread(widget);
thread.start();
logger.info("Started");

...

logger.debug("shutting down");
widget.shutDown();

try {
  logger.debug("doing join on thread");
  thread.join();
  logger.debug("returned from join");
} catch (InterruptedException e) {
  logger.error("Exception", e);
}

对join()的调用永远不会返回。

更新：

根据要求，我已经包含了我希望的完整（足够）代码示例，因为我现在拥有它。注意：我已采纳该建议并将受保护的boolean更改为AtomicBoolean。

public abstract class AbstractWidget implements Runnable {
  protected final AtomicBoolean   running  = new AtomicBoolean(true);
  public void shutDown() {
    running.set(false);
  }
}


public class ConcreteWidget extends AbstractWidget {
  @Override
  public void run() {
    while (running.get()) {
      // ... do stuff (including calling process() below)
    }
  }
  private void process() {
    try {
      // ... do stuff
    } catch (IOException e) {
      logger.error("Exception", e);
      running.set(false);
      return;
    }
  }
}

在“主要”逻辑中：

  private void startService() {
    widget = new ConcreteWidget(...);
    thread = new Thread(widget);
    thread.start();
    logger.info("Started");
  }

  public void close() {
    logger.debug("shutting down service");
    widget.shutDown();

    try {
      logger.debug("doing join on service thread");
      thread.join();
      logger.debug("returned from join");
    } catch (InterruptedException e) {
      logger.error("Exception", e);
    }
  }

BTW，仍然不起作用。

Answer 1

你的问题实际上很简单。当你调用widget.shutDown();时，线程实际上没有启动，所以当线程实际启动时，它会将running设置为true，并且永远不会停止。不使用running来终止循环，而是使用单独的stopped变量。

public abstract class AbstractWidget implements Runnable {
  // Other fields and methods omitted for brevity.
  private volatile boolean running = false;
  private valatile boolean stopped = false;

  public boolean isRunning() {
    return running;
  }

  public boolean hasStopped() {
    return stopped;
  }

  public void shutDown() {
    stopped = true;
  }
}

public class ConcreteWidget extends AbstractWidget {
  // Other fields and methods omitted for brevity.

  @Override
  public void run() {
    running = true;
    while (!stopped) {
      // ...
    }
    running = false;
    logger.info("Shutting down");
  }
}

使用此设置，您可能希望在停止前等待一段时间，否则循环将永远不会运行。

ConcreteWidget widet = new ConcreteWidget(...);
thread = new Thread(widget);
thread.start();
logger.info("Started");
...

try {
  Thread.sleep(500); // <--
} catch (Exception e) {}
logger.debug("shutting down");
widget.shutDown();

try {
  logger.debug("doing join on thread");
  thread.join();
  logger.debug("returned from join");
} catch (InterruptedException e) {
  logger.error("Exception", e);
}

Answer 2

您是否在widget.shutDown();之后立即运行thread.start();？

可能widget.shutDown();已在running = true;方法

中的run()代码之前运行

Answer 3

[捂脸]

事实证明问题是线程处理挂起并且永远无法检查running字段的状态。一旦我纠正了这个问题，它就运行得很好。

我确实更改了我的逻辑以使用AtomicBoolean而不是boolean，所以感谢您提供有用的建议。

在子类实例

3 个答案: