Question

我有几个使用不同比较方法的线程类。我将它们实现为扩展抽象类。例如，

public abstract class MatcherThread implements Runnable{
    List<String> clusters;
    int output;

    public MatcherThread(List<String> clusters){
        this.clusters = clusters;
    }

    public void run()
    {
        for(List<String> c: clusters) {
            compare(c);
        }
    }

    public int getOutput(){
       return output;
    }

    protected abstract void compare(String c);
}

public class MaxLength extends MatcherThread{
    public MaxLength(List<String> clusters){
      super(clusters);
      this.output = Integer.MAX_VALUE;
    }

    protected void compare(String c){
      if(c.length() > output) output = c.length();
    }
}

public class MinLength extends MatcherThread{
    public MinLength(List<String> clusters){
      super(clusters);
      this.output = 0;
    }

    protected void compare(String c){
      if(c.length() < output) output = c.length();
    }
}

现在，我想拥有一个可以运行任一线程的类。我的第一个想法是使此类通用，但是将工作分配给线程需要实例化它们。

import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Matcher<T extends MatcherThread>{

     protected List<Integer> runAll(List<String> clusters, int nthreads) {
        int n = clusters.size();
        int poolSize = nthreads;
        int step = n/poolSize;
        ExecutorService es = Executors.newFixedThreadPool(poolSize);
        List<T> tasks = new ArrayList<T>();
        for (int i = 0; i < poolSize; i++) {
            int start = i*step;
            int end = i == poolSize -1 ? n: (i+1)*step;

            List<List<String>> subcluster = new ArrayList<List<String>>(){{
                for (int ind=start; ind < end; ind++) add(clusters(ind));
            }};

            T task = new T(subcluster); //This is not allowed.
            tasks.add(task);
        }
        CompletableFuture<?>[] futures = tasks.stream().map(task -> CompletableFuture.runAsync(task, es)).toArray(CompletableFuture[]::new);
        CompletableFuture.allOf(futures).join();
        es.shutdown();

        List<Integer> output = new List<Integer>();
        for(T t : tasks) {
            output.add(t.getOutput());
        }
        return output;
    }
}

如何重新设计我的类，这样就不必实例化泛型类型，但是我仍然可以在比较函数之间轻松切换？

Answer 1

在这种情况下，通常会为Matcher提供某种工厂，以帮助创建适当的线程。在Java 8中，您可以例如使用Supplier界面：

public class Matcher {

    private final Supplier<? extends MatcherThread> threadSupplier;

    public Matcher(Supplier<? extends MatcherThread> threadSupplier) {
        this.threadSupplier = threadSupplier;
    }

     protected List<Integer> runAll(List<String> clusters, int nthreads) {

        // …
        MatcherThread task = threadSupplier.get();
        task.setSubcluster(subcluster); // refactor to allow setter injection
        tasks.add(task);
        // …

    }

}

然后，实例化匹配器，如下所示：

Matcher matcher = new Matcher(() -> new MaxLength());

这假定您添加了一个setSubcluster方法，而不是构造函数注入。另外，您也可以使用Function，或实现自己的工厂接口来坚持构造函数注入。

我应该如何设计线程，这样就不必实例化泛型？

1 个答案: