帶參數的Callable lambda表達式

Question

我想用泛型（我第一次嘗試使用泛型）和使用ExecutorService來實現「TaskExecutor」。

這裏是我的 「的TaskExecutor」 類：

public class ExecuteAlerterTask<T> { 
    public List<T> process(String executorName, Callable<T> task) throws ExecutionException, InterruptedException { 
     final ThreadFactory threadFactory = new ThreadFactoryBuilder() 
       .setNameFormat(executorName + "-%d") 
       .setDaemon(true) 
       .build(); 
     ExecutorService executor = Executors.newFixedThreadPool(10, threadFactory); 
     Collection<Future<T>> futures = new ArrayList<>(); 
     IntStream.range(1, 10).forEach(i -> { 
      Future<T> future = executor.submit(task); 
      futures.add(future); 
     }); 

     List<T> result = new ArrayList<>(); 
     for (Future<T> f : futures) { 
      result.add(f.get()); 
     } 
     executor.shutdown(); 
     return result; 
    } 
} 

這是我的方式來運行它：

@Test 
public void process() throws Exception { 
    Callable<String> callable =() -> "Do something on "; 
    ExecuteAlerterTask<String> executeAlerterTask = new ExecuteAlerterTask<>(); 
    List<String> result = executeAlerterTask.process("TaskName", callable); 
    result.forEach(System.out::println); 
} 

這裏是我的問題： 如何寫我的贖回，這會接受論點i at a line：

Future<T> future = executor.submit(task); 

E.g.所需結果將是：

Do something on 1 
Do something on 3 
Do something on 7 
Do something on 2 
<...etc...> 

如果別的東西是錯我的代碼 - 請讓我知道。上述

編輯

刪除工具可贖回

代碼是我真正想要做的抽象：

• IntRange真的被設置批次，其中從SQL獲取數據的。可調用 確實實現瞭如何處理這些SQL批處理的邏輯。

EDIT2

所有的建議後，我已經下面的解決方案：

public class ExecuteAlerterTask<T> { 
    public List<T> process(String executorName, Collection<Callable<T>> task) throws ExecutionException, InterruptedException { 
     final ThreadFactory threadFactory = new ThreadFactoryBuilder() 
       .setNameFormat(executorName + "-%d") 
       .setDaemon(true) 
       .build(); 
     ExecutorService executor = Executors.newFixedThreadPool(10, threadFactory); 
     Collection<Future<T>> futures = executor.invokeAll(task); 

     List<T> result = new ArrayList<>(); 
     for (Future<T> f : futures) { 
      result.add(f.get()); 
     } 
     executor.shutdown(); 
     return result; 
    } 
} 

而且方式來運行它：

@Test 
    public void process() throws Exception { 
     Collection<Callable<String>> tasks = new ArrayList<>(); 
     IntStream.range(1, 10).forEach(i -> { 
      tasks.add(new Task(i).callable); 
     }); 

     ExecuteAlerterTask<String> executeAlerterTask = new ExecuteAlerterTask<>(); 
     List<String> result = executeAlerterTask.process("TaskName", tasks); 
     result.forEach(System.out::println); 
    } 

    private class Task { 
     private int i; 
     private Callable<String> callable =() -> "Doing something on i: " + i; 
     private Task(int i) { 
      this.i = i; 
     } 
    } 

EDIT3

運行它更簡單的方法：

@Test 
    public void process() throws Exception { 
     Collection<Callable<String>> tasks = new ArrayList<>(); 
     IntStream.range(1, 10).forEach(i -> { 
      tasks.add(() -> "Do something on i: " + i * 2); 
     }); 

     ExecuteAlerterTask<String> executeAlerterTask = new ExecuteAlerterTask<>(); 
     List<String> result = executeAlerterTask.process("TaskName", tasks); 
     result.forEach(System.out::println); 
    } 

我想我最終的解決方案非常滿意。謝謝大家！

Answer 1

首先，你根本不需要call()，你也不需要在這個類中實現Callable<T>，因爲你從不使用它。

要創建一個可調用你想要的方式，你couldd做

Callable<String> task; // from the parameter 
int i; // from the loop 
Callable<String> wrapper =() -> { return task.call() + " on " + i; } 
executor.submit(wrapper); 

你基本上給拉姆達外部變量i作爲參數。

Answer 2

這是不可能的。如果這是一個lambda，你不能將一個變量傳遞給可調用對象。在另一方面，你可以使用實現Callable並具有可變二傳手自己的特定對象：

public class CallableWithParam implements Callable<String> { 

    // protected for subclassing call() 
    // volatile for multi-threaded reasons 
    protected volatile int param = 0; 

    public void setParam(int param) { 
     this.param = param; 
    } 

    @Override 
    public String call() { 
     return "my param is: " + param; 
    } 

} 

用法：

@Test 
public void process() throws Exception { 
    CallableWithParam callable = new CallableWithParam() { 
    @Override 
     public String call() { 
      // an anonymous inner class is almost a lambda ;) 
      return "my param is: " + param + "in subclass"; 
     } 
    }; 
    callable.setParam(3); 
    ExecuteAlerterTask<String> executeAlerterTask = new ExecuteAlerterTask<>(); 
    List<String> result = executeAlerterTask.process("TaskName", callable); 
    result.forEach(System.out::println); 
} 

或者，您可以設置帕拉姆在構造函數中，而不是的二傳手。