Question

设置

正在运行的程序正在执行任意计算并将状态（整数值，表示进度）写入文件。整数值只能递增。

现在我正在开发一个其他应用程序，它可以（除其他外）对这些整数值执行算术运算，例如比较。文件将被永久删除并由其他程序写入。因此，无法保证文件随时存在。

基本上，应用程序需要执行任意的操作，但是对其他程序的进度有约束，即，如果其他程序已完成足够的工作，它可能只执行某些操作。

问题

执行算术运算时，应用程序不应关心整数值的来源。特别是，访问这些整数值不得抛出异常。我应该如何分离执行io访问时可能发生的所有不良事件？

请注意，我不希望执行线程阻塞，直到可以从文件中读取值。例如，假设文件系统以某种方式死亡，那么整数值将不会更新，但主线程仍应继续工作。这种愿望是由算术比较作为谓词的定义驱动的，它具有两个结果，真实和错误，但没有第三个“错误” - 结果。这就是为什么我认为从文件中读取的值需要以某种方式缓存。

限制

Java 1.7，Scala 2.11

当前方法

我有一个看起来好像可行的解决方案，但我不确定是否会出现问题。

解决方案是为每个文件维护这些整数值的缓存。核心功能是缓存的getter，而有一个单独的“updater”-thread，它不断读取文件并更新chaches。

如果发生错误，生产者应注意（即记录错误），但继续运行，因为不完整的计算不应影响后续计算。

我目前正在做的最小例子看起来像这样：

object Application {

  def main(args: Array[String]) {
    val caches = args.map(filename => new Cache(Paths.get(filename))
    val producer = new Thread(new Updater(caches)))
    producer.start()
    execute(caches)
    producer.interrupt()
  }
  def execute(values: Array[AccessValue]) {
    while (values.head.getValue < 5) {/* This should never throw an exception */}
  }
class Updater(caches: Array[Cache]) {
  def run() {
    var interrupted = false
    while(!interrupted) {
      caches.foreach{cache => 
        try {
          val input = Files.newInputStream(cache.file)
          cache.updateValue(parse(input))
        } catch {
          case _: InterruptedException => 
            interrupted = true
          case t: Throwable => 
            log.error(t)
            /*continue as if nothing happend*/
        }
      }
    }
  }
  def parse(input: InputStream): Int = input.read() /* In reality, some xml parsing */
}
trait AccessValue{ 
  def getValue: Int // should not throw an exception
}
class Cache(val file: Path) extends AccessValue{ 
  private val value = 0
  def getValue = value
  def updateValue(newValue: Int) { value = newValue }
}

这样做可以在合成测试设置上工作，但我想知道是否会发生不好的事情。此外，如果有人以不同的方式处理问题，我会很高兴听到如何。

是否会有一个可以导致其他线程疯狂的throwable？我在考虑像OutOfMemoryException或StackOverflow这样的东西。我是否需要以不同的方式处理它们，或者它无关紧要，因为例如整个应用程序都会死掉？
如果在try块之外，甚至在catch块中抛出InterruptException，会发生什么？是否有更好的方法来终止线程？
类Cache的成员值必须声明为volatile吗？我并不关心读取和写入的顺序，但是编译器不能仅仅因为它推断出值是常数而“优化”读取值。
有许多不同的并发相关库。你建议我使用新线程（...）以外的东西.start（）？如果是，您建议使用什么设施？我知道Scala的ExecutionContext，Future和Java的Executors类，它为线程池提供了各种静态构造函数。但是，我之前从未使用过任何这些，我不知道它们的优点和缺点。我也偶然发现了“Akka”的名字，但我的猜测是使用Akka对于我想达到的目标来说是过度的。

谢谢

Answer 1

我建议在并发时阅读oracle's documentation。

当一个线程写入一个值而另一个线程读取一个值时，应始终使用synchronized块或将该值声明为volatile。否则，无法保证一个线程写入的值对另一个线程可见（请参阅oracle's documentation建立之前发生的关系）。

OutOfMemoryException可以影响其他线程，因为OutOfMemoryException引用的堆空间在线程之间共享。 StackOverflow异常只会杀死它发生的线程，因为每个线程都有自己的堆栈。

如果你不需要两个线程之间的某种同步，那么你可能不需要任何Futures或Executors。

我应该如何维护从文件中读取的值的缓存？

设置

问题

限制

当前方法

1 个答案: