Listener creazione thread

Question

È possibile scrivere listener di creazione thread in java? Ad esempio usando aop ?!

voglio dire qualcosa di simile che se la mia domanda crea un thread vorrei registrare questo oggetto nel mio tavolo, contenitore o qualcosa del genere.

Answer 1

penso che questo sarebbe possibile con AOP (AspectJ per esempio). Tuttavia, è ancora necessario creare i propri tipi Thread e ThreadGroup/Executor, a meno che non sia possibile ricompilare le classi JDK con il compilatore di aspetto. Definire il punto di taglio sul metodo start del thread se si desidera registrarsi all'avvio del thread o sullo createThread del pool se si desidera registrarsi sulla creazione degli oggetti thread.

---

I seguenti lavori solo se si ricompilato il JDK con il compilatore aspetto: Tutte le discussioni sono iniziate con Thread.start, in modo da scrivere la pointcut per questo metodo è possibile utilizzare consigli di fare ciò che si desidera. Naturalmente questo non è perfetto poiché ad es. un executor di cacheThreadPool potrebbe non avviare un nuovo thread per ogni attività, ma forse se si registra un pointcut su Runnable.run e Callable.call anziché su Thread.start, ciò potrebbe essere sufficiente.

Answer 2

Vorrei creare un thread che elenchi continuamente tutti i thread in esecuzione sulla JVM.
Quindi ogni volta che notifica che un nuovo thread è apparso, notificherà in ogni modo una classe nel codice.

Ecco alcuni link su come elencare tutte le discussioni attualmente in esecuzione sulla JVM:

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

2. Listing All Running Threads

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

un codice che inizia:

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

Forse un ThreadGroup è quello che ti serve. Tutti i thread sono membri di un ThreadGroup e quando si avvia una nuova discussione viene aggiunta allo stesso gruppo come principale per impostazione predefinita.

In teoria è possibile (ma non consigliato) sottoclasse ricevere una notifica quando un thread viene aggiunto o rimosso dal gruppo.

È probabile che il polling dei thread di questi gruppi o il polling di tutti i thread sia una soluzione migliore.