Java多线程任务

Question

我有这样的任务

构建类StringTask，模拟长期计算，这里由字符串拼接组成。

类构造函数接收要复制的字符串作为参数，以及表示字符串要放大多少次的数字。

类必须实现Runnable接口(interface)，在其run()方法中进行字符串的复制，应该使用+ used to string variables来完成(这是长期操作)。 + 的使用是强制条件。

StringTask 类的对象被视为一个可以相互并行执行的任务。

状态任务是:

• CREATED - 任务已创建，但尚未开始执行，
• RUNNING - 任务在单独的线程中执行
• ABORTED - 任务已中断
• READY - 任务成功并准备好结果。

在 StringTask 类中定义以下方法:

• public String getResult () - 返回结果串联
• public TaskState getState () - 返回任务的状态

• public void start () - 在单独的线程中运行任务

  public void abort() - 暂停任务代码的执行和线程的运行

• public boolean isDone () - 如果任务完成则返回 true通常或通过中断，否则为假

程序代码如下:

public class Main {

    public static void main(String[] args) throws InterruptedException {
        StringTask task = new StringTask("A", 70000);
        System.out.println("Task " + task.getState());
        task.start();
        if (args.length > 0 && args[0].equals("abort")) { 
        /*
            <- here add the code interrupting the task after a second 
            and run it in a separate thread
        */
        }
        while (!task.isDone()) {
            Thread.sleep(500);
            switch(task.getState()) {
                case RUNNING: System.out.print("R."); break;
                case ABORTED: System.out.println(" ... aborted."); break;
                case READY: System.out.println(" ... ready."); break;
                default: System.out.println("uknown state");
            }
        }
        System.out.println("Task " + task.getState());
        System.out.println(task.getResult().length());
    }
}

不带参数运行应该放这样的东西:

任务已创建R.R.R.R.R.R.R.R.R. ... 准备好。任务就绪70000并以参数中止运行并放置如下内容:

任务已创建R. ... 中止。任务中止31700注意事项 1. Main.java文件只能在标有/* <- */的地方修改注意2. 不要使用方法System.exit(...)

得到了这个解决方案

package zad2;

/**
 * Created by szhyhalo on 09.04.17.
 */
public class StringTask implements Runnable {


    public enum TaskState {
        CREATED, RUNNING, ABORTED, READY
    }

    public boolean isDone = false;
    public TaskState myState;
    public String text;
    public String resultText;
    public Thread myThread;
    public int operations;

    public StringTask() {
        myState = TaskState.CREATED;
    }

    public StringTask(String a, int i) {
        this();
        text = a;
        operations = i;
        resultText = "";
    }

    public boolean isDone() {
        if (myState == TaskState.READY || myState == TaskState.ABORTED) return true;
        return false;
    }

    public void abort() {
        while (operations != 0) {
            resultText += text;
            operations--;
        }
    }

    @Override
    public void run() {
        while (operations != 0) {
            resultText += text;
            operations--;
        }
        myState = TaskState.READY;
    }

    public TaskState getState() {
        return myState;

    }

    public String getResult() {
        return resultText;
    }

    public void start() {
        myThread = new Thread(this);
        myState = TaskState.RUNNING;
        myThread.start();


    }
}

但是经过测试，系统给出了这些错误，我不知道该如何解决。

Behaviour tests results - scoring decrease = -7

时间:我们使用参数“Y”调用 StringTask 构造函数 i 80000，然后我们启动任务

• abort 方法应该停止任务的执行(abort() 方法不会终止线程)

  scoring decrease = -7

---

需求测试结果 - 得分下降 = -2

案例 1:得分下降 = -1 - 一些变量应该有 volatile 修饰符

案例 2:得分下降 = -1 - 你应该通过中断 lub isInterrupted 方法检查中断标志

如何解决？我试过了，但我不知道。

Answer 1

由于我们都不知道实际失败的行为测试，我们所能做的就是猜测。

首先，在 StringTask 中，您应该使用 private volatile 变量。为了 encapsulation，它们应该是 private .它们应该是 volatile 以便多线程更改可见。参见 this SO Q&A进一步讨论 volatile。

关于操作计数器，你最好使用AtomicInteger因为它支持多线程递减和递增操作。

这些是精炼的领域:

private volatile TaskState myState;
private volatile String text;
private volatile String resultText;
private final AtomicInteger operations = new AtomicInteger(0);

这需要在第二个构造函数中做一点小改动:

public StringTask(String a, int i) {
    this();
    text = a;
    operations.set(i); // this is the change
    resultText = "";
}

此外，abort() 方法需要在run() 中停止执行。我会这样做，abort() 更新 myState 标志，run() 继续读取该标志:

public void abort() {
    myState = TaskState.ABORTED;
}

@Override
public void run() {
    myState = TaskState.RUNNING;
    while (operations.get() != 0 && myState != TaskState.ABORTED) {
        resultText += text;
        operations.decrementAndGet();
    }
    if (myState != TaskState.ABORTED) {
        myState = TaskState.READY;
    }
}

请注意，上述这些方法使用了 AtomicInteger() 的 get() 和 decrementAndGet() 方法。这是一个轻微的不便，我们必须为非常安全的减量/增量操作付出代价。