Question

我想在Runnable上设置参数，然后获取值。

我写了这段代码。当我运行此代码时，返回 [2、3、3] 。因为线程共享temp_value。

然后我添加了已发表评论的睡眠。结果为 [1、2、3] 。效果很好！但这不是真正的多线程，对吗？

即使它正在运行多线程，但我也需要等待每个进程完成以获取共享值。

如何解决这个问题？

import java.util.ArrayList;

public class Foo implements Runnable {
    private int temp_value;
    private ArrayList<Integer> values = new ArrayList<Integer>();
    private ArrayList<Integer> newValues = new ArrayList<Integer>();

    public Foo(ArrayList<Integer> values) {
        this.values = values;
    }

    public static void main(String[] args) {

//      make initial values
        ArrayList<Integer> values = new ArrayList<Integer>();
        values.add(1);
        values.add(2);
        values.add(3);

//      set values then process and get new values
        Foo foo = new Foo(values);
        foo.startAppendValue(foo);
        System.out.println(foo.getNewValues());

    }

    public void startAppendValue(Foo foo) {

        Thread thread = null;
        int max = values.size();
        for (int i = 0; i < max; i++) {
            foo.temp_value =foo.values.get(i);
            thread = new Thread(foo);
            thread.start();
//          try {
//              Thread.sleep(10);
//          } catch (Exception e) {
//              // TODO: handle exception
//          }
        }
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }


    @Override
    public void run() {
        newValues.add(temp_value);
    }

    public ArrayList<Integer> getNewValues() {
        return this.newValues;
    }
}

Answer 1

您可以使用Callable和ExecutorService来完成任务

public class MyCallable implements Callable<Integer> { //Callable is like Runnable but can return value
  private Integer value;

  public MyCallable(Integer v) {
    value = v;
  }

  public Integer call() {
    return value;
  }

  public static void main(String[] args) {
    ExecutorService exec = Executors.newFixedThreadPool(3); //Creating thread pool with 3 worker threads
    List<Integer> values = Arrays.asList(1, 2, 3);
    List<Future<Integer>> futures = new ArrayList<>(values.size());
    List<Integer> newValues = new ArrayList<>(values.size());

    for (Integer v : values) {
        futures.add(exec.submit(new MyCallable(v))); //Submit tasks to worker threads to do stuff in background
    }

    for (Future<Integer> f : futures) {
        try {
            newValues.add(f.get()); // get calculated result from worker thread or block waiting for result to become available
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }

    System.out.println(newValues);
    exec.shutdownNow();
  }
}

Answer 2

我会使用List.parallelStream()

public class Foo {

    public static void main(String[] args) {

//      make initial values
        List<Integer> values = new ArrayList<Integer>();
        values.add(1);
        values.add(2);
        values.add(3);

        // process each value using multiple threads.
        List<Integer> results = values.parallelStream()
                                      .map(Foo::processValue)
                                      .collect(Collectors.toList());
    }

    static Integer processValue(Integer i) {
        // do something interesting
        return i;
    }
}

即使它正在运行多线程，但我也需要等待每个进程完成以获取共享值。

正确，您需要确定。

每个线程只有它是数据的副本。
以线程安全的方式访问共享的集合。

我尝试使用Threads编写此代码，但是在这里发布它太痛苦了。

Answer 3

我认为您的共享数据有误。为此，请把我放在私人空间。您可以像这样上课：从Foo类中删除temp_value并将可运行部件移动到名为PV的新类中。

Class PV implements Runnable{
    int index;
    Foo foo;
    PV(int index,Foo foo){
        this.index = index;
        this.foo = foo;
    }
}
    @Override
    public void run() {
      this.foo.newValues.add(foo.values.get(index));
    }
}


PV[] pvArr = new PV[max];
    for (int i = 0; i < max; i++) {
        pvArr[i] = new PV(i,foo);
        foo.temp_value =foo.values.get(i);
        thread = new Thread(pvArr[i]);
        thread.start();

如何在Runnable上设置参数然后获取值？

3 个答案: