简单java线程测试程序不工作

我试图用java制作一个非常简单的“计算器”来理解线程，因为它是我在java中发现的并发编程场景的实现

在我的课堂上呈现的方式如下：

cobegin
  a = a + 10
  b = b - 3
coend
c = b - a
w = c + 1

我做了一些研究，并试图用java实现它，但它将所有值返回0

主类 公共类线程{

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        int a = 0;
        int b = 0;
        Threader t1 = new Threader(a, '+', 10); 
        System.out.println("a" + a);
        Threader t2 = new Threader(b, '-', 3);
        System.out.println("b" + b);
        t1.start();
        a = t1.res;
        System.out.println("a>>thread" + a);
        t2.start();
        b = t2.res;
        System.out.println("b>>thread" +b);
        int c = b - a;
        System.out.println("c" + c);
        int w = c + 1;
        System.out.println("w" +c);

    }

类应该执行线程处理

public class Threader extends Thread {

    private char op;
    private int a;
    private int b;
    public int res;

    public Threader(int _a, char _op, int _b) {
        a = _a;
        b = _b;
        op = _op;
    }

    @Override
    public void run() {
        Operator ope = new Operator();
        res = ope.operar(a, op, b);
    }
}

运算符类

public class Operator {

    public int operar(int a, char op, int b) {
        if (op == '+') {
            return sum(a, b);
        }
        if (op == '-') {
            return substr(a, b);
        }
        if (op == '*') {
            return mult(a, b);
        }
        if (op == '/') {
            return div(a, b);
        } else {
            return Integer.MAX_VALUE;
        }
    }

    public int sum(int a, int b) {
        return a + b;
    }

    public int substr(int a, int b) {
        return a - b;
    }

    public int mult(int a, int b) {
        return a * b;
    }

    public int div(int a, int b) {
        if (b > 0) {
            return a / b;
        } else {
            return Integer.MAX_VALUE;
        }
    }
}

我错过了什么？

---

Java中有更好的方法解决这个问题吗？

请确保加入您的线程，以了解它们已经完成：

t1.start();
t1.join();

这显然忽略了线程的意义，因此请确保在需要结果时加入

更多说明：

您不需要扩展

线程
。您不是在生成特殊线程，而是在生成特殊任务。默认线程足以运行它们

使用此类：

public class RunnableTask implements Runnable {

    // consider using a getter
    public int res;
    private int a;
    private char c;
    private int i;

    public RunnableTask(int a, char c, int i) {
        this.a = a;
        this.c = c;
        this.i = i;
    }

    @Override
    public void run() {
        Operator ope = new Operator();
        this.res = ope.operar(a, this.c, this.i);
    }

}

现在使用如下线程：

public class Main {
    /**
     * @param args
     *            the command line arguments
     * @throws InterruptedException 
     */
    public static void main(String[] args) throws InterruptedException {
        int a = 0;
        int b = 0;
        RunnableTask task1 = new RunnableTask(a, '+', 10);
        RunnableTask task2 = new RunnableTask(b, '-', 3);
        Thread t1 = new Thread(task1);
        System.out.println("a" + a);
        Thread t2 = new Thread(task2);
        System.out.println("b" + b);
        t1.start();
        t1.join();
        a = task1.res;
        System.out.println("a>>thread" + a);
        t2.start();
        t2.join();
        b = task2.res;
        System.out.println("b>>thread" + b);
        int c = b - a;
        System.out.println("c" + c);
        int w = c + 1;
        System.out.println("w" + c);

    }
}

确保加入您的线程以知道它们已完成：

t1.start();
t1.join();

这显然忽略了线程的意义，因此请确保在需要结果时加入

更多说明：

您不需要扩展
线程
。您不是在生成特殊线程，而是在生成特殊任务。默认线程足以运行它们

使用此类：

public class RunnableTask implements Runnable {

    // consider using a getter
    public int res;
    private int a;
    private char c;
    private int i;

    public RunnableTask(int a, char c, int i) {
        this.a = a;
        this.c = c;
        this.i = i;
    }

    @Override
    public void run() {
        Operator ope = new Operator();
        this.res = ope.operar(a, this.c, this.i);
    }

}

现在使用如下线程：

public class Main {
    /**
     * @param args
     *            the command line arguments
     * @throws InterruptedException 
     */
    public static void main(String[] args) throws InterruptedException {
        int a = 0;
        int b = 0;
        RunnableTask task1 = new RunnableTask(a, '+', 10);
        RunnableTask task2 = new RunnableTask(b, '-', 3);
        Thread t1 = new Thread(task1);
        System.out.println("a" + a);
        Thread t2 = new Thread(task2);
        System.out.println("b" + b);
        t1.start();
        t1.join();
        a = task1.res;
        System.out.println("a>>thread" + a);
        t2.start();
        t2.join();
        b = task2.res;
        System.out.println("b>>thread" + b);
        int c = b - a;
        System.out.println("c" + c);
        int w = c + 1;
        System.out.println("w" + c);

    }
}

在我看来，这是一个关于如何使用线程的糟糕例子

对于任何线程，我总是问的第一个问题是，“它等待什么？”服务器线程等待来自客户端的连接，客户端线程等待特定客户端发送下一个命令，GUI线程等待键盘和鼠标输入，工作线程等待任务执行，等等

你的线程不等待任何东西（顺便说一下，你的程序中有一个bug：你的主线程甚至不等待工作线程计算结果）

您的程序是该规则一个不寻常异常的退化示例：它是一个执行单个计算的程序。在这种情况下，创建不必等待的工作线程是有意义的，因为每个线程从创建它的那一刻起就知道它的任务。程序创建线程，线程执行它们的任务，main线程等待单独的结果，组合它们，然后程序完成

但这是一个不寻常的情况

更典型的是，计算密集型程序将使用一个工作线程池来执行许多计算。这些工作线程在不进行积极计算时会等待下一项工作。这就是它们的定义

如果您想学习如何思考线程，请思考线程等待的内容

依我看。
依我看，这是一个关于如何使用线程的糟糕示例

对于任何线程，我总是问的第一个问题是，“它等待什么？”服务器线程等待来自客户端的连接，客户端线程等待特定客户端发送下一个命令，GUI线程等待键盘和鼠标输入，工作线程等待任务执行，等等

你的线程不等待任何东西（顺便说一下，你的程序中有一个bug：你的主线程甚至不等待工作线程计算结果）

您的程序是该规则一个不寻常异常的退化示例：它是一个执行单个计算的程序。在这种情况下，创建不必等待的工作线程是有意义的，因为每个线程从创建它的那一刻起就知道它的任务。程序创建线程，线程执行它们的任务，main线程等待单独的结果，组合它们，然后程序完成

但这是一个不寻常的情况

更典型的是，计算密集型程序将使用一个工作线程池来执行许多计算。这些工作线程在不进行积极计算时会等待下一项工作。这就是它们的定义

如果您想学习如何思考线程，请思考线程等待的内容

IMO.
这些操作非常简单，执行速度如此之快，以至于您无法看到多线程的效果。请尝试在
线程器的
run
方法中执行更复杂的操作。问题不在于运行速度，它们根本不会影响我的变量值。
a0 b0 a>>thread0 b>>thread0 c0 w0
我得到了输出，这是因为
res
字段在
Threader
实例中可能还没有更新。请将fild标记为
volatile
，并确保在执行
Threader
后检索结果。如果要确保
Threader
已完成（并避免使用关键字
volatile
），使用
Thread#join
告诉当前线程等待其他线程的执行以继续。
volatile
可能不起作用；线程初始化和完成需要相对较长的时间。操作非常简单，执行速度非常快，您无法看到多线程的效果。t我在
Threader
的
run
方法中做了一些更复杂的事情。问题不在于运行速度，它们根本不会影响变量的值。
a0 b0 a>>thread0 b>>thread0 c0 w0
我得到了输出，这是因为
res
字段在
Threader
实例中可能还没有更新。将fild标记为
volatile
，确保在执行
线程器后检索结果。如果要确保
线程器
已完成（并避免使用关键字
volatile
），请使用
线程#连接
告知当前thr