Question

我正在为 Java 6 ^{* 1）} 开发变压器，它执行一种部分评估，但为简单起见，我们考虑一下 Java程序的抽象语法树解释。

如何通过解释程序模拟Thread的行为？

目前，我想到了以下几点：

AstInterpreter 应该实现java.lang.Runnable。它还应该重写java.lang.Thread（或其子类）的每个新实例表达式，用新的 AstInterpreter替换Thread的目标（java.lang.Runnable） instance：

编辑：提供更复杂的示例。

编辑2：评论1。

目标计划：

class PrintDemo {
   public void printCount(){
    try {
         for(int i = 5; i > 0; i--) {
            System.out.println("Counter   ---   "  + i );
         }
     } catch (Exception e) {
         System.out.println("Thread  interrupted.");
     }
   }
}

class ThreadDemo extends Thread {
   private Thread t;
   private String threadName;
   PrintDemo  PD;

   ThreadDemo( String name,  PrintDemo pd){
       threadName = name;
       PD = pd;
   }
   public void run() {
     synchronized(PD) {
        PD.printCount();
     }
     System.out.println("Thread " +  threadName + " exiting.");
   }

   public void start ()
   {
      System.out.println("Starting " +  threadName );
      if (t == null)
      {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}

public class TestThread {
   public static void main(String args[]) {
      PrintDemo PD = new PrintDemo();

      ThreadDemo T1 = new ThreadDemo( "Thread - 1 ", PD );
      ThreadDemo T2 = new ThreadDemo( "Thread - 2 ", PD );

      T1.start();
      T2.start();

      // wait for threads to end
      try {
         T1.join();
         T2.join();
      } catch( Exception e) {
         System.out.println("Interrupted");
      }
   }
}

程序1（ThreadTest - 解释字节码）：

new Thread( new Runnable() {
   public void run(){
      ThreadTest.main(new String[0]);
   }
});

程序2（ThreadTest - AST解释）：

final com.sun.source.tree.Tree tree = parse("ThreadTest.java");

new Thread( new AstInterpreter() {
   public void run(){
      interpret( tree );
   }

   public void interpret(com.sun.source.tree.Tree javaExpression){
   //...  

   }
});

生成的程序2 是否正确模拟了线程的初始程序1 的行为？

^1）目前，source=8 / target=8方案已被接受。

Answer 1

我看到两个选项：

选项1：JVM线程。每次解释的程序调用Thread.start时，您也调用Thread.start并使用另一个解释器启动另一个线程。这很简单，使您不必执行锁定和其他操作，但您可以减少控制。

选项2：模拟线程。类似于在单处理器上实现多任务处理 - 使用时间切片。您必须在解释器中实现锁定和休眠，并跟踪模拟的线程以了解哪些线程已准备好运行，哪些线程已完成，哪些线程已被阻止等等。

您可以执行一个线程的指令，直到它阻塞或经过一段时间或达到一些指令计数，然后找到另一个可能正在运行的线程并切换到运行该线程。在操作系统的上下文中，这称为进程调度 - 您可能希望研究此主题以获得灵感。

Answer 2

使用经验解释器计算实际值时，不能合理地进行部分评估。你需要象征性的价值观。

对于部分评估，您需要的是在每个程序点计算符号程序状态，然后根据该程序点处已知的状态简化程序点。您可以通过在程序启动时写下您对状态的了解来开始部分评估过程。

如果你用完整的符号状态装饰每个程序点并立即将它们全部保留，你就会快速耗尽内存。因此，更实用的方法是通过沿控制流路径使用深度优先搜索的方法枚举所有控制流路径，随时计算符号状态。当此搜索回溯时，它会抛弃正在探索的当前路径上的最后一个节点的符号状态。现在，您保存的状态在流图的深度大小上是线性的，在方法中通常非常浅。（当方法调用另一个方法时，只需扩展控制流路径以包含该调用）。

要处理runnables，您必须在单独的runnable中建模计算的交错。交错两个线程的（巨大）状态将变得非常快。可能在这里保存的一件事是线程计算的大多数状态对于该线程是完全本地的，因此根据定义对另一个线程是不可见的，并且您不必担心交错该状态的那一部分。因此，我们留下模拟两个线程看到的状态交错，以及模拟每个线程的本地状态。

您可以通过控制流中隐含但模拟的并行分叉对此交错进行建模：在每个模拟步骤中，一个线程进行一步进展，或者另一个进程（一般化为N个线程）。你得到的是每个分支的每个程序点的新状态;程序点的实际状态是该过程为每个状态生成的状态的分离。

您可以通过对各个属性的属性进行“分离”来简化实际的状态分离。例如，如果您知道一个线程在特定程序点将x设置为负数，而另一个线程在同一点将其设置为正数，则可以将x的状态汇总为“非零”。你需要一个非常丰富的类型系统来模拟可能的值特征，或者你可以使用一个贫穷的系统来保守地将变量属性的分离计算为“什么都不知道”。

此方案假定内存访问是原子的。它们通常不是真正的代码，所以你也必须对它进行建模。如果最终在“相同”步骤中从两个线程对存储器位置进行冲突的读写操作，可能最好让解释器只是抱怨你的程序有竞争条件。竞争条件不会使您的程序出错，但只有非常聪明的代码才能以不会破坏的方式使用竞赛。

如果此方案正确完成，当一个线程A对另一个线程B已在使用的对象上的同步方法进行调用时，可以停止将A与B交叉，直到B离开同步方法。如果线程A和B之间在同一抽象对象上永远不会发生干扰，则可以从对象声明中删除同步声明。我认为这是你最初的目标

所有这些都不容易组织，并且运行时间/空间可能非常昂贵。试图绘制所有这些相当费力的例子，所以我不会在这里做。

模型检查器https://en.wikipedia.org/wiki/Model_checking在生成“状态空间”方面做了非常相似的事情，并且有类似的时间/空间问题。如果你想了解更多关于如何管理国家这样做，我会阅读有关这方面的文献。

模拟java.lang.Thread的最佳方法是什么？

2 个答案: