Java多线程，从单独的类访问列表

Question

Just to start off, I'm pretty inept at Java and especially multithreading, so what I'm asking might sound a bit ordinary. I am attempting to create a program in which I create three threads which each accomplish the specific task of depicting certain values between ten integers, such as average, deviation, etc. How would I approach this?

I am attempting to create four classes, one for the main program, and three for each of the calculations of the values between each: class "Average" for the average of the ten numbers in the array, class "Median" for the median, etc. The code for the other 3 classes I can easily write, no problem there. My main problem is that since the list "integers" is not available outside the class, I can't write the code for finding each of the values I need in the three programs.

Is there a better way to write this so I can actually access the list from inside the classes for each of the threads?

import java.util.*;

public class ThreadDemo
{
    public static void main(String[] args)
    {
        Random number = new Random();
        List integers = new ArrayList();

        for (int i = 0; i < 10; i++)
        {
            integers.add(number.nextInt(101));
        }

        Thread average = new Thread(new Average());
        Thread median = new Thread(new Median());
        Thread deviation = new Thread(new Deviation());

        average.start();
        median.start();
        deviation.start();
    }
}

class Average extends Thread
{
    public void run()
    {
         // code for finding average
    }
}

class Median extends Thread
{
    public void run()
    {
         // code for finding median
    }
}

class Deviation extends Thread
{
    public void run()
    {
         // code for finding deviation
    }
}

Answer 1

There are a lot of options to achieve what you are trying to do. I will outline two:

• each computation method implementing the Callable interface and taking data into the instance constructor;
• each computation method implementing the Function interface and passing data into the call via the closure.

It is generally advisable to program to interfaces, that is require an interface as method argument . All below examples follow this by implementing Callable or Function and working with those high level interfaces elsewhere. The code for both cases looks very similar with the main difference being the remapping of Function to Callable in the latter case using the closure state.

Let's start with some common utilities (statics for brevity only):

The following method will create a Collection of 100 random integers in [0,100]:

private static Collection<Integer> ints() {
    Random random = new Random();
    return random.ints(100, 0, 100)
        .boxed()
        .collect(Collectors.toList());
}

The following method will execute a collection of Callable s concurrently on a cached executor pool. Each callable is generic and will deliver a double value. Those values (in random order) will be collected and returned as a list:

private static List<Double> concurrently(Collection<Callable<Double>> callables) throws InterruptedException, ExecutionException {
    ExecutorService executors = Executors.newCachedThreadPool();
    Collection<Future<Double>> futures = executors.invokeAll(callables);
    List<Double> res = new ArrayList<>();
    for (Future<Double> future: futures) {
        res.add(future.get());
    }
    executors.shutdownNow();
    return res;
}

Now let's get back to the core logic.

Case 1: Implementing Callable

class Averager<V extends Number> implements Callable<Double> {

    private final Collection<V> values = new ArrayList<>();

    Averager(Collection<V> values) {
        this.values.addAll(values);
    }

    @Override
    public Double call() {
        double sum = 0.0;
        for (V value : values) {
            sum += value.doubleValue();
        }
        return Double.valueOf(sum / values.size());
    }
}

class Medianer<V extends Number> implements Callable<Double> {

    private final Collection<V> values = new ArrayList<>();

    Medianer(Collection<V> values) {
        this.values.addAll(values);
    }

    @Override
    public Double call() {
        List<V> sorted = new ArrayList<>(values);
        sorted.sort(Comparator.comparingDouble(Number::doubleValue));
        // TODO treat odd/even number of elements separately
        return Double.valueOf(sorted.get(sorted.size() / 2).doubleValue());
    }
}

Note: whenever you take a collection as a constructor argument, do not store the reference to the original collection provided in a private field, copy values. If collections are very large, do not pass them to constructor or make unmodifiable.

@Test
public void usingCallable() throws InterruptedException, ExecutionException {
    Collection<Integer> values = ints();

    Collection<Callable<Double>> callables = new ArrayList<>();
    callables.add(new Averager<>(values));
    callables.add(new Medianer<>(values));

    List<Double> res = concurrently(callables);
    System.out.println(res);
}

Case 2: Implementing Function

class Averager<V extends Number> implements Function<Collection<V>, Double> {
    @Override
    public Double apply(Collection<V> values) {
        double sum = 0.0;
        for (V value : values) {
            sum += value.doubleValue();
        }
        return Double.valueOf(sum / values.size());
    }
}

class Medianer<V extends Number> implements Function<Collection<V>, Double> {
    @Override
    public Double apply(Collection<V> values) {
        List<V> sorted = new ArrayList<>(values);
        sorted.sort(Comparator.comparingDouble(Number::doubleValue));
        // TODO treat odd/even number of elements separately
        return Double.valueOf(sorted.get(sorted.size() / 2).doubleValue());
    }
}

@Test
public void usingFunction() throws InterruptedException, ExecutionException {
    Collection<Integer> values = ints();

    Collection<Function<Collection<Integer>, Double>> functions = new ArrayList<>();
    functions.add(new Averager<>());
    functions.add(new Medianer<>());

    List<Callable<Double>> callables = functions.stream().map(f -> (Callable<Double>) () -> f.apply(values)).collect(Collectors.toList());

    List<Double> res = concurrently(callables);
    System.out.println(res);
}

I personally prefer the latter one because your computation methods become generic functions, that is implementing the generic Function interface and can be used in other contexts.

Reworking case 1 and 2 with lambdas

You can do some interesting things with lambdas here. For the case of functions, you can just predefine them as lambdas instead of constructing new instances of specifically defined class:

static final Function<Collection<Integer>, Double> averager = (values) -> {
        double sum = 0.0;
        for (Integer value : values) {
            sum += value.doubleValue();
        }
        return Double.valueOf(sum / values.size());
    };

static final Function<Collection<Integer>, Double> medianer = (values) -> {
        List<Integer> sorted = new ArrayList<>(values);
        sorted.sort(Comparator.comparingDouble(Number::doubleValue));
        // TODO treat odd/even number of elements separately
        return Double.valueOf(sorted.get(sorted.size() / 2).doubleValue());
    };

Followed later by:

Collection<Function<Collection<Integer>, Double>> functions = new ArrayList<>();
functions.add(averager);
functions.add(medianer);

For the case of callable you can nicely inline them:

Collection<Callable<Double>> callables = new ArrayList<>();
callables.add(() -> {
    double sum = 0.0;
    for (Integer value : values) {
        sum += value.doubleValue();
    }
    return Double.valueOf(sum / values.size());
});
callables.add(() -> {
    List<Integer> sorted = new ArrayList<>(values);
    sorted.sort(Comparator.comparingDouble(Number::doubleValue));
    // TODO treat odd/even number of elements separately
    return Double.valueOf(sorted.get(sorted.size() / 2).doubleValue());
});

Note how you do not need external declarations in the latter case.

Note : as you do not want your results in a random order you will need you function return a pair, eg Map.Entry , with a key and a value. But I will leave that to you to exercise.

A sample execution for one of those methods would print something like

[53.01,57.0]

Answer 2

You can pass as a constructor argument. Also, after starting the threads, you must call join , otherwise the main thread will not wait the others to finish:

average.start();
median.start();
deviation.start();

average.join();
median.join();
deviation.join();

```