Yeni bir iş parçacığında Java geri çağırma yürütme

Question

Bu projede, bir Manager olay sıralaması gerçekleştirir ve olayın sonucunu döndürmek için geri arama kullanılır (geri arama Runnable'u uzatmaz). Yönetici, olayları gönderen ayrı bir iş parçacığı üzerinde çalışır. Olaylar sona erdiğinde, aynı iş parçacığı geri aramaları çağırır. Bu, bir önceki etkinliğin geri dönüşünün sona ermesinden önce bir sonraki olayın gönderilmeyeceği anlamına gelir. Bunu önlemek için, yöneticinin her geri arama için yeni bir iş parçacığı oluşturmasını ve geri aramaları orada yürütmesini sağlamayı düşünüyorum. Bu çözüm tasarım uygulamaları açısından ne kadar iyidir ve bunu başarmak için daha iyi bir yol var mı?

Answer 1

Basit Callback kodu:

import java.util.concurrent.*; 
import java.util.*; 

public class CallBackDemo{ 
    public CallBackDemo(){ 
     System.out.println("creating service"); 
     ExecutorService service = Executors.newFixedThreadPool(10); 

     try{ 
      for (int i=0; i<10; i++){ 
       Callback callback = new Callback(i+1); 
       MyCallable myCallable = new MyCallable((long)i+1,callback); 
       Future<Long> future = service.submit(myCallable); 
       //System.out.println("future status:"+future.get()+":"+future.isDone()); 
      } 
     }catch(Exception err){ 
      err.printStackTrace(); 
     } 
     service.shutdown(); 
    } 
    public static void main(String args[]){ 
     CallBackDemo demo = new CallBackDemo(); 
    } 
} 
class MyCallable implements Callable<Long>{ 
    Long id = 0L; 
    Callback callback; 
    public MyCallable(Long val,Callback obj){ 
     this.id = val; 
     this.callback = obj; 
    } 
    public Long call(){ 
     //Add your business logic 
     System.out.println("Callable:"+id+":"+Thread.currentThread().getName()); 
     callback.callbackMethod(); 
     return id; 
    } 
} 
class Callback { 
    private int i; 
    public Callback(int i){ 
     this.i = i; 
    } 
    public void callbackMethod(){ 
     System.out.println("Call back:"+i); 
     // Add your business logic 
    } 
} 

çıkışı:

creating service 
Callable:1:pool-1-thread-1 
Call back:1 
Callable:2:pool-1-thread-2 
Call back:2 
Callable:8:pool-1-thread-8 
Call back:8 
Callable:3:pool-1-thread-3 
Call back:3 
Callable:10:pool-1-thread-10 
Callable:4:pool-1-thread-4 
Call back:10 
Callable:7:pool-1-thread-7 
Call back:7 
Callable:6:pool-1-thread-6 
Call back:6 
Callable:9:pool-1-thread-9 
Callable:5:pool-1-thread-5 
Call back:9 
Call back:4 
Call back:5 

Özet:

1. tercih tercih ExecutorService ile Manager değiştirin.
2. Callaback nesnesini Callable/Runnable nesnesine geçirebilir veya Callable/Runnable içine Callback nesnesini oluşturabilirsiniz. Örneğimde, Callback nesnesini Callable'a açıkça ilettim.

3. Sonucu döndürmeden önce, Callable nesnesi, Callback yöntemini çağırır. Mevcut etkinliğin yanıtını almazsanız devam etmeyi engellemek istiyorsanız, aşağıdaki satırın sadece uncomment'ı.

   System.out.println("future status:"+future.get()+":"+future.isDone()); 
   

Bunu önlemek ve çizgi yorumladı yukarıda dolayısıyla devam edeceğiz düşünüyorum. Callback yöntem çağrısı için yeni iş parçacığı oluşturmanız gerekmez. Eşzamansız olarak Callback olayını işlemek isterseniz, bir tane daha ExecutorService oluşturabilir ve etkinliği gönderebilirsiniz.

Answer 2

Görevi yürüten iş parçacığı da olur, ayrıca geri arama işlemini de yürütürüm. Her defasında bir Thread oluşturmak yerine, bir ExecutorService kullanmanızı öneririm.

public static <T> void submit(ExecutorService service, 
           Callable<T> callable, 
           Consumer<T> callback) { 
    service.submit(() -> { 
     try { 
      callback.accept(callable.call()); 
     } catch (Throwable t) { 
      // log the Throwable 
     } 
    }); 
}