将 Runnable 转换为可运行的 Workers 数组

Question

我正在尝试创建一个可运行的数组来存储工作类，然后使用 Thread 数组开始工作。

public class SimpleThreads {
  public static void main(String[] args) {
    System.out.println("main starts.");

    int num1 = 5;
    int num2 = 7;

    // create Workers
    Runnable r1 = new Worker(num1, num2);
    Runnable r2 = new Worker(num1 * 10, num2 * 10);
    
    Runnable[] runs = new Worker(num1, num2);

    // create Threads to run Workers

    Thread[] threads = new Thread[args.length];

    for (int i = 0; i < args.length; i++) {

      threads[i] = new Thread(runs[i]);
    }

    Thread t1 = new Thread(r1);
    Thread t2 = new Thread(r2);

    // start threads
    t1.start();
    t2.start();
    // Returns the adition to the main
    System.out.println(((Worker) r1).doCalc());
    System.out.println(((Worker) r2).doCalc());

    int grandTotal = 0;

    grandTotal = ((Worker) r1).doCalc() + ((Worker) r2).doCalc();
    System.out.println("The Grand Total " + grandTotal);

    System.out.println("main ends.");
  }
}

/*
 * the class that becomes a thread, can be named anything, must have
 * "implements Runnable" which requires the public void run() method
 */
class Worker implements Runnable {
  private int val1;
  private int val2;
  private long threadId;

  // constructor
  Worker(int val1, int val2) {
    this.val1 = val1;
    this.val2 = val2;
  }

  // required method
  public void run() {
    threadId = Thread.currentThread().getId();
    doCalc();
  }

  // does the actual work
  public int doCalc() {
    return val1 + val2;

    // System.out.printf("[%03d] %3d + %3d = %3d\n", threadId, val1, val2, result);
  }
}

基本上，有人可以帮我弄清楚我在这里做错了什么吗？我收到此错误 Type mismatch: cannot convert from Worker to Runnable[]Java(16777233)

我的预期结果应该是

创建一个可运行的worker数组

然后在我的线程数组中使用该可运行工作线程数组并自动启动线程，而不是对每个线程一一硬编码。

Answer 1

看来你的概念有点混乱。

您将所有线程和可运行对象存储在数组中，然后继续创建非数组实例并使用它们。 你声明了runnables和线程，然后你直接从你的主线程调用计算方法。

让我们先清理启动部分：

public class SimpleThreads {
  public static void main(String[] args) {
    System.out.println("main starts.");

    int num1 = 5;
    int num2 = 7;

    // Build an array of workers.
    Worker[] workers = new Worker[] {
      new Worker(num1, num2),
      new Worker(num1 * 10, num2 * 10)
    };

    // create Threads to run Workers and start them
    Thread[] threads = new Thread[workers.length];

    for (int i = 0; i < workers.length; i++) 
    {
      threads[i] = new Thread(workers[i]);
      threads[i].start();
    }

所以，现在我们有一个工人数组和一个线程数组。 如果您愿意，可以将 workers 数组声明为 Runnable 类型，但我们希望稍后使用 worker 的方法。

让我们看看我们是否可以从工人那里获取数据。我们将添加一个getResult() 方法。

class Worker implements Runnable {
  private int val1;
  private int val2;
  private int result;

  // constructor
  Worker(int val1, int val2) {
    this.val1 = val1;
    this.val2 = val2;
  }

  // required method
  public void run() {
      doCalc();
  }

  // does the actual work
  private void doCalc() {
     result = val1 + val2;
  }

  public int getResult() { return result; }
}

所以，一旦我们的 worker 完成，我们可以调用 getResult() 来查看它的最终答案是什么。

所以，回到主线程，让我们等待线程完成，然后将它们的结果相加。

int grandTotal = 0;

// Wait for threads to finish
for(int i=0;i<threads.length;i++)
{
    threads[i].join();
}

// Read their results
for (int i=0; i<workers.length;i++)
{ 
    grandTotal += workers[i].getResult();
}
System.out.println("The Grand Total " + grandTotal);