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

Question

设置

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

现在我正在开发另一个应用程序，它可以(除其他外)对这些整数值执行算术运算，例如比较。这些文件被永久删除并由不同的程序写入。因此，不能保证文件在任何时候都存在。

基本上，应用程序需要执行任意操作，但对其他程序的进度有限制，即，只有当其他程序完成了足够的工作时，它才可以执行某些操作。

问题

执行算术运算时，应用程序不应关心整数值来自何处。特别是，访问这些整数值不得引发异常。我应该如何区分执行 io 访问时可能发生的所有不好的事情？

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

限制

Java 1.7、Scala 2.11

当前方法

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

解决方案是为每个文件维护这些整数值的缓存。核心功能是提供缓存的 getter ，同时有一个单独的“更新器”线程不断读取文件并更新缓存。

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

我当前正在做的事情的一个最小示例如下所示:

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 }
}

这样做适用于综合测试设置，但我想知道是否会发生不好的事情。另外，如果有人愿意以不同的方式解决这个问题，我很高兴听到如何解决。

• 是否存在可能导致其他线程失控的可抛出对象？我正在考虑类似 OutOfMemoryException 或 StackOverflow 的问题。我是否需要以不同的方式处理它们，或者这并不重要，因为，例如，整个应用程序无论如何都会死掉？
• 如果 InterruptException 被抛出到 try block 之外，甚至是 catch block 中，会发生什么？有没有更好的方法来终止线程？
• 类Cache的成员值必须声明为 volatile 的吗？我不太关心读取和写入的顺序，但编译器不能仅仅因为推断出该值是常量而“优化”读取该值。
• 有很多不同的并发相关库。你建议我使用 new Thread(...).start() 以外的东西吗？如果是，您建议使用什么设施？我知道Scala的ExecutionContext、Future和Java的Executors类，它们为线程池提供了各种静态构造函数。然而，我以前从未使用过这些，也不知道它们的优点和缺点。我还偶然发现了“Akka”这个名字，但我的猜测是，使用 Akka 对于我想要实现的目标来说有点矫枉过正。

谢谢

Answer 1

我建议通读oracle's documentation关于并发。

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

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

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