Oyente de creación de subprocesos

Question

¿Es posible escribir un oyente de creación de subprocesos en java? Por ejemplo, usando aop ?!

Quiero decir algo así como que si mi aplicación crea un hilo me gustaría registrar este objeto en mi propia tabla, contenedor o algo así.

Answer 1

creo que esto sería posible con AOP (aspectj por ejemplo). Pero aún se requiere crear sus propios tipos Thread y ThreadGroup/Executor, a menos que pueda recompilar las clases JDK con el compilador de aspecto. Defina el punto de corte en el método start de su subproceso si desea registrarse en el inicio de subproceso o en el createThread de su grupo si desea registrarse en la creación de los objetos de subproceso.

---

Las siguientes obras sólo si se vuelve a compilar el JDK con el compilador aspecto: Todas las roscas se inician con Thread.start, por lo que escribir un punto de corte para ese método, puede utilizar consejos para hacer lo que desea. Por supuesto, esto no es perfecto, ya que p. un ejecutor cacheado de ThreadPool puede no iniciar un nuevo hilo para cada tarea, pero tal vez si registra un punto en Runnable.run y Callable.call en lugar de Thread.start, eso podría ser suficiente.

Answer 2

Crearía un hilo que enumera continuamente todos los hilos en ejecución en la JVM.
Luego, cada vez que notifique que ha aparecido un nuevo hilo, notificará de alguna forma una clase en su código.

Éstos son algunos enlaces sobre cómo enumerar todos los temas actualmente se ejecuta en la JVM:

1. Get a List of all Threads currently running in Java

2. Listing All Running Threads

========= ===

Un código de inicio:

ThreadCreationListener.java

public interface ThreadCreationListener { 
    public void onThreadCreation(Thread newThread); 
} 

ThreadCreationMonitor.java

public class ThreadCreationMonitor extends Thread { 
    private List<ThreadCreationListener> listeners; 
    private boolean canGo; 

    public ThreadCreationMonitor() { 
     listeners = new Vector<ThreadCreationListener>();//Vector class is used because many threads may use a ThreadCreationMonitor instance. 
     canGo = true; 
     // Initialize the rest of the class here... 
    } 

    // Most important methods 
    public void addListener(ThreadCreationListener tcl) { 
     listeners.add(tcl); 
    } 

    public void removeListener(ThreadCreationListener tcl) { 
     listeners.remove(tcl); 
    } 

    public void run() { 
     List<Thread> runningThreads; 
     List<Thread> lastRunningThreads; 

     while(canGo) { 
      // Step 1 - List all running threads (see previous links) 
      // runningThreads = ... 

      // Step 2 - Check for new threads and notify all listeners if necessary 
      if (runningThreads.removeAll(lastRunningThreads)==true) { 
       for(Thread t : runningThreads) { 
        for(ThreadCreationListener tcl : listeners) { 
         tcl.onThreadCreation(t);//Notify listener 
        } 
       } 
      } 
     } 
    } 

    public void shutdown() { 
     canGo = false; 
    } 

}

MyThreadInfoConsumer.java

public class MyThreadInfoConsumer implements ThreadCreationListener { 
    public void onThreadCreation(Thread newThread) { 
     // Process here the notification... 
    } 
} 

Main.java

public class Main { 
    public static void main(String[] args) { 
     ThreadCreationMonitor tcm = new ThreadCreationMonitor(); 
     tcm.start(); 

     MyThreadInfoConsumer myTIC = new MyThreadInfoConsumer(); 
     tcm.addListener(myTIC); 

     // rest of your code... 
     // Don't forget to call tcm.shutdown() when exiting your application ! 
    } 
} 

Answer 3

Tal vez un ThreadGroup es lo que necesita. Todos los subprocesos son miembros de un grupo de subprocesos y, cuando inicia un subproceso nuevo, se agrega al mismo grupo que su elemento primario de forma predeterminada.

En teoría, es posible (pero no se recomienda) que se notifique a la subclase cuando se agrega o elimina un subproceso del grupo.

Es probable que el sondeo de los hilos de estos grupos o el sondeo de todos los hilos sea una mejor solución.