De combien de façons sont pour la création d'un nouveau thread en Java?

Threads peuvent être créés principalement dans 3 manières différentes

1. Étendre la java.lang.Fil de la classe de

class SampleThread extends Thread {

    //method where the thread execution will start 
    public void run(){
        //logic to execute in a thread    
    }

    //let’s see how to start the threads
    public static void main(String[] args){
       Thread t1 = new SampleThread();
       Thread t2 = new SampleThread();
       t1.start();  //start the first thread. This calls the run() method.
       t2.start(); //this starts the 2nd thread. This calls the run() method.  
    }
} 

1. Mettre en œuvre la java.lang.Praticable interface

class A implements Runnable{

    @Override
    public void run() {

        //implement run method here 
    }

    public static void main() {
        final A obj = new A();

        Thread t1 = new Thread(new A());

        t1.start();
    }


}

1. Mettre en œuvre la java.util.simultanées.Callable interface

class Counter implements Callable {

    private static final int THREAD_POOL_SIZE = 2;

    //method where the thread execution takes place
    public String call() {
        return Thread.currentThread().getName() + " executing ...";
    }

    public static void main(String[] args) throws InterruptedException,
            ExecutionException {
        //create a pool of 2 threads
        ExecutorService executor = Executors
                .newFixedThreadPool(THREAD_POOL_SIZE);

        Future future1 = executor.submit(new Counter());
        Future future2 = executor.submit(new Counter());

        System.out.println(Thread.currentThread().getName() + " executing ...");

        //asynchronously get from the worker threads
        System.out.println(future1.get());
        System.out.println(future2.get());

    }
}

Faveur Appelable interface avec l'Exécuteur cadre pour la mise en pool de threads.

L'Exécutable ou Remboursables par anticipation de l'interface est préféré par rapport à l'extension de la classe Thread

OriginalL'auteur ankit249

Le moyen privilégié de départ threads en Java 6 est en utilisant les Exécuteurs:

    ExecutorService es = Executors.newCachedThreadPool();
    Runnable r = <your runnable here>;
    es.execute(r);

OriginalL'auteur Mister Smith

Il y a seulement Deux façons de créer un Thread déjà vous avez mentionné, mais une troisième manière est-il d'invoquer le Fil.

En java1.5 il existe une autre façon d'invoquer un thread. C'est par “ExecutorService”. Toutes ces classes sont de la “java.util.simultanées”. Il existe différentes façons de créer un “ExecutorService” à l'aide “Exécuteurs” de l'usine de la classe. Ce qui suit est l'une des façon de créer de la “ExecutorService”..

ExecutorService es= Exécuteurs testamentaires.newSingleThreadExecutor();

RunnableImpl r = new RunnableImpl();

Avenir fu=es.soumettre(r);

À l'aide de “ExecutorService” méthodes nous pouvons soumettre eighter Praticable ou Remboursables par anticipation au service de l'exécution.

Comment jamais, cela ne peut pas être dit que la nouvelle façon de créer un Thread. C'est parce que ExecutorService utilise en interne “ThreadFactory” classe pour créer un nouveau thread qui utilise en interne dans la première ou la deuxième méthode. Nous devons donc dire qu'il y a seulement deux façons de créer des threads, mais il y a une nouvelle façon java1.5 à invoquer un fil, mais de ne pas créer un Thread.

OriginalL'auteur subhashis