[Java] reflection + threads

[ally]

...posto una porzione di codice che unisce un esempio di reflection con un sistema a thread...che ne pensate di tale implementazione?...cercavo un modo per eseguire tramite thread multipli un istanza senza che questa fosse stata prevista per l'uso a thread e senza doverla rismanacciare...

...MultiThread è la sola classe da configurare...presenta informazioni come il numero di thread...la classe da lanciare ed eventuali argomenti da passare...come tipo e valore...

public MultiThread(){
        
        int firstThread = 1;
        int lastThread = 60;
        int threads = 3;
        String instance = "it.ally.test.Test";
        Class[] classTypeArguments = new Class[] {String.class};
        Object[] classArguments = new Object[] {"una stringa"};
        
        long startTime = System.currentTimeMillis();
        try {
            this.threadHandler = new ThreadHandler(firstThread, lastThread);
            for (int i = 0; i < threads; i++){
                this.threadWorker = new ThreadWorker(("Thread "+i), this.threadHandler,instance,classTypeArguments,classArguments);
                this.threadWorker.start();
            }
            while(this.threadWorker.isAlive()) 
                Thread.sleep(30);
        } 
        catch (Exception ex) {
            System.err.println("Error:" + ex);
            ex.printStackTrace();
        }

        long endTime = System.currentTimeMillis();
        System.out.println("All thread launch in "  + (endTime - startTime)+" waiting for ending of instance!");  
    }

...i restanti metodi gestiscono i thread...

public class ThreadHandler implements Enumeration {
    
    int _firstInstance = 0;
    int _lastInstance = 0;
    int _nextInstance = 0;

    public ThreadHandler(int first, int last){
        
        this._firstInstance = first;
        this._nextInstance = first;
        this._lastInstance = last;

    }

    public boolean hasMoreElements(){
        return (this._nextInstance <= this._lastInstance);
    }

    public Object nextElement(){
        return new Threads(this._nextInstance++);
    }
}

public class ThreadWorker extends Thread {
    
    ThreadHandler _threadHandler = null;
    String _instanceName = null;
    Class[] _classTypeArguments = null;
    Object[] _classArguments = null;

    public ThreadWorker(String name, ThreadHandler threadHandler ,String  instanceName,Class[] classTypeArguments,Object[] classArguments)
    {
        super(name);
        this._threadHandler = threadHandler;
        this._instanceName = instanceName;
        this._classTypeArguments = classTypeArguments;
        this._classArguments = classArguments;
    }

    public void run() {
        
        Threads thread = null;
        boolean quit = false;

        while (!quit) {
            thread = null;
            synchronized(this._threadHandler)
            {
                if (!this._threadHandler.hasMoreElements()) {
                    quit = true;
                    return;
                }
                thread = (Threads) this._threadHandler.nextElement();
            }
            
            if (null != thread) thread.threadMethod(this.getName(),this._instanceName,this._classTypeArguments,this._classArguments);
        }
    }
}

...e la classe thread che tramite reflection istanzia la classe che si vuole rendere multithread...

public class Threads {
    
    int _thread = -1;

    public Threads(int thread){
        this._thread = thread;
    }

    void threadMethod(String name,String instanceMethod,Class[] classTypeArguments,Object[] classArguments) {
        
        try {
            System.out.println(this._thread+" "+name+" instance method = "+instanceMethod);
            Class reflectionClass;
            Constructor intArgsConstructor;
            reflectionClass = Class.forName(instanceMethod);
            intArgsConstructor = reflectionClass.getConstructor(classTypeArguments);
            intArgsConstructor.newInstance(classArguments);
        }

        catch (Exception e) {
           System.out.println(e);
        }
    }
}

...è un thread (!) aperto per avere un feed back su quanto ho scritto o magari dare uno spunto se qualcuno sta smanacciando con tali strati...

...ciao Andrea...

[banryu79]

Ciao ally,
come esperimento mi sembra interessante, potresti postare un piccolo "caso d'uso" a mo' di esempio?
Appena ho un po' di tempo (stasera) studio con calma la tua realizzazione (e se vuoi ne scambio/posto una mia su un altro argomento, su cui sto "smanacciando" in questi giorni, appena l'ho rifinita).

[ally]

Originariamente inviato da banryu79

Ciao ally,
come esperimento mi sembra interessante, potresti postare un piccolo "caso d'uso" a mo' di esempio?
Appena ho un po' di tempo (stasera) studio con calma la tua realizzazione (e se vuoi ne scambio/posto una mia su un altro argomento, su cui sto "smanacciando" in questi giorni, appena l'ho rifinita).

...l'ho implementando per esigenze legate all'uso piu' efficente della banda...avevo la necessità di lanciare degli aggiornamenti con upload/download e dovevo rendere il tutto piu' veloce senza saturare la connessione...da qui ho cercato di separare i metodi di download dalla gestione a thread...quindi l'esempio da utilizzare puo' essere un qualsiasi metodo di url download...il tutto è ampiamente migliorabile...mettici mano!...

...ciao Andrea...

[banryu79]

Originariamente inviato da ally

...l'ho implementando per esigenze legate all'uso piu' efficente della banda...avevo la necessità di lanciare degli aggiornamenti con upload/download e dovevo rendere il tutto piu' veloce senza saturare la connessione...da qui ho cercato di separare i metodi di download dalla gestione a thread...quindi l'esempio da utilizzare puo' essere un qualsiasi metodo di url download...il tutto è ampiamente migliorabile...mettici mano!...

...ciao Andrea...

Ok grazie delle ulteriori spiegazioni.
Non ho ancora approfondito perchè questo wend ho dedicato il tempo libero a questa cosa (sei hai osservazioni in merito non esitare ).

Torno non appena provo il tuo codice, ho postato giusto per farti sapere che ci sono
Ciao.