ThreadPoolExecutor'ı geçersiz kılarExecute yöntemi - herhangi bir cons? Kanca yöntemleri

Question

Avantaj önce ve her görev yürütülmesinden sonra denir

beforeExecute(Thread, Runnable) ve afterExecute(Runnable, Throwable)

beforeExecute(Thread, Runnable) ve afterExecute(Runnable, Throwable) yöntem. Bunlar yürütme ortamını değiştirmek için kullanılabilir; Örneğin, ThreadLocals reinitializing istatistikleri toplamak veya günlük girişlerini

Ben yakalanmamış istisnalar işlemek için Özel'i ThreadPoolExecutor kullanıyorum ekledi. Runnable ve Callable numaralı telefonlara try{} catch{} blokları ekleyebilirim ancak geliştiriciyi bu blokları Runnable ve Callable görevlerine eklemek için zorlayamayacağınız bir senaryo varsayın.

Bu CustomThreadPoolExecutor, aritmetik durum simüle etmek için Sıfır afterExecute() aşağıdaki gibi ThreadPoolExecutor yöntemi (ı atanmış değişken b değeri geçersiz kılar.

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

class CustomThreadPoolExecutor extends ThreadPoolExecutor { 

    public CustomThreadPoolExecutor() { 
     super(1,10,60,TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(1000)); 
    } 

    protected void afterExecute(Runnable r, Throwable t) { 
    super.afterExecute(r, t); 
    if (t == null && r instanceof Future<?>) { 
     try { 
     Object result = ((Future<?>) r).get(); 
     System.out.println(result); 
     } catch (CancellationException ce) { 
      t = ce; 
     } catch (ExecutionException ee) { 
      t = ee.getCause(); 
     } catch (InterruptedException ie) { 
      Thread.currentThread().interrupt(); // ignore/reset 
     } 
    } 
    if (t != null) 
     t.printStackTrace(); 
    } 
} 


public class CustomThreadPoolExecutorDemo{ 

    public static void main(String args[]){ 
     System.out.println("creating service"); 
     //ExecutorService service = Executors.newFixedThreadPool(10); 
     CustomThreadPoolExecutor service = new CustomThreadPoolExecutor(); 
     service.submit(new Runnable(){ 
       public void run(){ 
        int a=4, b = 0; 
        System.out.println("a and b="+a+":"+b); 
        System.out.println("a/b:"+(a/b)); 
        System.out.println("Thread Name in Runnable after divide by zero:"+Thread.currentThread().getName()); 
       } 
      }); 
     service.shutdown(); 
    } 
} 

submit() yana çerçeveye özel gizler, I afterExecute() yöntem geçersiz adres yakalamak İstisna. Bu yöntemde

, aşağıda deyimi ile çağrı engelleme ekledi

Object result = ((Future<?>) r).get(); 

Şu anda 10 tane queue capacity as 1000 tane var. Varsayıyorum benim Runnable tamamlamak için 5 saniye sürüyor. Ben herhangi bir performans yükü VEYA bu yaklaşımla herhangi bir olumsuz yönleri üstlenmeden ediyorum, afterExecute() yöntemini geçersiz kılarak

?

Answer 1

Hayır, engelleme çağrısı yükü getirmek olmaz onun Eğer void runWorker(Worker w)

beforeExecute(wt, task); 
Throwable thrown = null; 
try { 
    task.run(); 
} catch (RuntimeException x) { 
    thrown = x; throw x; 
} catch (Error x) { 
    thrown = x; throw x; 
} catch (Throwable x) { 
    thrown = x; throw new Error(x); 
} finally { 
    afterExecute(task, thrown); 
} 

Answer 2

Daha iyi bir çözüm, Geleceğe bekle submit() döndü ve sonra da ana iş parçacığı istisna işleyebilir yerine vasisi hack sizin için yazdırmak için.

diğer alternatif arzu durum işleme uygulayan Runnable ortak tabanı, örneğin kullanmak olacaktır: iştir çünkü tamamlanmış,

public abstract class BaseRunnable implements Runnable { 
    public final run() { 
    try { 
     runImpl(); 
    } catch(Throwable t) { 
     t.printStackTrace(); 
    } 
    } 
    protected abstract runImpl() throws Exception; 
}