Java如何在作業完成後調用或通知調用類？

Question

我有簡單的調用線程哪些做簡單的工作。當條件滿足時
我想調用或通知基類（啓動線程的那個）
工作完成。
這樣做的最好方法是什麼？

class TaskThread implements Runnable 
{ 

    private int result = -1; 
    public TaskThread() 
    { 

    }  
    //must be thread safe 
    public synchronized int getResult() 
    { 
     return result; 
    } 

    @Override 
    public void run() { 

     if(result==-1 || result < 0) 
     { 
      StartFoo(); 
      result = InvokeAPI(); 
      if(result == 1) 
      { 
      // HERE i like to do something to notify the outside world that the job is done ... 
      } 

     } 
    } 
} 


//Base class 
public class ScheduledThreadsManager { 

    private static ScheduledThreadsManager instance = null; 
    private ScheduledExecutorService scheduler; 
    private Runnable pTaskThread = null ; 
    protected ScheduledThreadsManager() 
    { 

    } 

    //must be set only once in the app life cycle 
    public void Init(int corePoolSize, 
         long TimeUnitINSeconds) 
    { 
      pTaskThread = new TaskThread(); 
      scheduler = Executors.newSingleThreadScheduledExecutor(); 
      scheduler.scheduleAtFixedRate(pTaskThread,1,TimeUnitINSeconds,TimeUnit.SECONDS); 
    } 
    public int getResult() 
    { 
     return pTaskThread.; 
    } 
    // Runtime initialization 
    // By defualt ThreadSafe 
    public static ScheduledThreadsManager getInstance() { 
     if(instance == null){ 
      synchronized (ScheduledThreadsManager.class) { 
       if(instance == null){ 
        instance = new ScheduledThreadsManager(); 
       } 
      } 
     } 
     return instance; 
    } 


    public void ShutdownNow() 
    { 

     pTaskThread = null ; 
     scheduler.shutdown(); 
    } 
} 

現在這就是我稱之爲：

//somewhere in the code 

ScheduledThreadsManager.getInstance().init(1,10); 
int runThis = true; 
while(runThis) 
{ 
    int ifOne = ScheduledThreadsManager.getInstance().getResult() 
    if(ifOne==1) 
    { 
     runThis = false; 
     ScheduledThreadsManager.getInstance().ShutdownNow() 
    } 
} 

林不知道，是最好的方法，我可以以某種方式可以從TaskThread run方法方法和更新ScheduledThreadsManager？

Answer 1

您可以通過界面實現它，例如，

interface SomethingToBeCalled{ 
void notfiy(); 
} 

你BaseClass的擴展了這個

ScheduledThreadsManager implements SomethingToBeCalled{ 
void notify() {...}; 
} 

，爲你的任務建構這個接口

public TaskThread(SomethingToBeCalled smth) 
    { 
     this.smth = smth; 
    } 

，現在您可以通知BaseClass的

if(result == 1) 
    { 
    smth.notify(); 
    } 

Answer 2

我認爲最好的辦法是給任務的回調函數：

Runnable callback =() -> System.out.println("done!"); 

然後在你的任務只是在末尾添加callback.run();。或者，如果您的任務返回了需要使用的值，請使用Consumer而不是Runnable。

這裏是一個工作示例：

public class Task implements Runnable { 

    private final Consumer<String> callback; 

    public Task(Consumer<String> callback) { 
     this.callback = callback; 
    } 

    @Override 
    public void run() { 
     // do actual work here instead 
     String result = new Random().nextInt(2) == 0 ? "a" : "b"; 

     // call a private method in Caller 
     callback.accept(result); 
    } 

} 

public class Caller { 

    public static void main(String[] args) throws InterruptedException { 
     ExecutorService executorService = Executors.newCachedThreadPool(); 

     executorService.submit(new Task((result) -> print(1, result))); 
     executorService.submit(new Task((result) -> print(2, result))); 
     executorService.submit(new Task((result) -> print(3, result))); 

     Thread.sleep(2000); 
    } 

    private static void print(int id, String result) { 
     System.out.println("task " + id + " done, returned: " + result); 
    } 

} 

這可以讓你如請撥打Caller的專用方法，您的Task將不知情。

Answer 3

不要通知調用對象：使用ExecutorService和Future。

您可以提交一個Runnable到ExecutorService並取回一個Future：

Future<?> future = executorService.submit(myRunnable); 

現在你可以調用future.get()（任選一超時），這將阻塞，直到未來完成：

future.get(); 
future.get(5, TimeUnit.MINUTES); 

這意味着你不需要引入任何新的回調接口或類似的東西。您也不需要立即致電future.get()：您可以提交一大堆任務，稍後再致電get。

請注意，如果您向ExecutorService提交Callable<T>，則會返回Future<T>：如果您希望長時間運行的計算返回值，這非常有用。

番石榴擴展Future接口與ListenableFuture，它允許您執行Future完成後回調。 Java 8也增加了CompleteableFuture，但我仍然處於黑暗時代，所以我從來沒有用過:) :)