1. Erben Sie die Thread-Klasse

public class ThreadCreator extends Thread{

    public static void main(String[] args) {
       //第一種方式：
       ThreadCreator creator = new ThreadCreator();
       Thread thread = new Thread(creator,"線程1");
       thread.start();
       //第二種方式：
       Thread thread = new ThreadCreator();
       thread.start();
       //第三種方式：
       new ThreadCreator().start();
　　　}
 
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "run");
    }
}

2. Implementieren Sie die Runnable-Schnittstelle

(kostenloses Teilen von Lernvideos: Java-Video-Tutorial )

public class ThreadCreator implements Runnable{

    public static void main(String[] args) {
       ThreadCreator creator = new ThreadCreator();
       Thread thread = new Thread(creator,"線程1");
       thread.start();
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "run");
    }
}

3. Implementieren Sie die Callable-Schnittstelle

public class ThreadCreator implements Callable<Integer> {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
       ThreadCreator creator = new ThreadCreator();
       FutureTask futureTask = new FutureTask(creator);
       Thread thread = new Thread(futureTask,"線程");
       thread.start();
       System.out.println(futureTask.get());
    }

    @Override
    public Integer call() {
        return 1024;
    }
}

4. Thread-Pool ExecutorService

public class ThreadCreator{

   static ExecutorService service = Executors.newFixedThreadPool(5);

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //execute無(wú)返回值
        service.execute(new ThreadTask(1,"1"));
        //submit有返回值
        Future<Integer> result = service.submit(new ThreadTaskCall());
        System.out.println(result.get());
        service.shutdownNow();
    }
    static class ThreadTask implements Runnable{
        private int param1;
        private String param2;
        public ThreadTask(int param3,String param4){
            this.param1 = param3;
            this.param2 = param4;
        }
        @Override
        public void run() {
            System.out.println(param1+param2);
        }
    }

    static class ThreadTaskCall implements Callable<Integer>{
        @Override
        public Integer call() throws Exception {
            return 1024;
        }
    }
}

Der Unterschied zwischen Submit und Execute im Thread-Pool:

(1) Die zul?ssigen Aufgabentypen sind unterschiedlich: ?Execute“ kann nur ausführbare Aufgaben akzeptieren, und ?Submit“ kann auch aufrufbare Aufgaben akzeptieren.

(2) Rückgabewert: ?execute“ hat keinen Rückgabewert. Sobald die Aufgabe übermittelt wurde, k?nnen die Ausführungsergebnisse im aktuellen Thread nicht überwacht werden. Submit verfügt über einen Rückgabewert vom Typ Future, der zum Empfangen von Rückgabewerten oder zum Reagieren auf Ausnahmen verwendet wird. Wird über die Methode get() abgerufen.

Die unterste Ebene von Submit hei?t immer noch Execute, ist aber auf dieser Basis mit einer zukünftigen Ebene gekapselt, und alle w?hrend der Ausführung generierten Ausnahmen werden in einer Variablen gekapselt:

public void run() {
        if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                         null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        } finally {
            runner = null;
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }
protected void setException(Throwable t) {
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
            outcome = t;
            UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
            finishCompletion();
        }
    }

Zus?tzlich , spring Die Zeitplananmerkung verwendet die übermittlungsverarbeitungsmethode als Referenz.

5. Anonyme innere Klasse

public class ThreadCreator {

    public static void main(String[] args) {

        //繼承Thread類(lèi)
        new Thread() {
            @Override
            public void run() {
                System.out.println("extends Thread Class!");
            }
        }.start();
        //實(shí)現(xiàn)Runnable接口
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("implement Runnable!");
            }
        }).start();
        //實(shí)現(xiàn)Callable接口
        new Thread(new FutureTask<Integer>(new Callable() {
            @Override
            public Integer call() throws Exception {
                return 1024;
            }
        })).start();
        //lambda表達(dá)式
        new Thread(() -> System.out.println("execute single code")).start();
        new Thread(() -> {
            System.out.println("execute multiple code");
        }).start();
    }
}

Lambda-Thread-Pool:

public class ThreadCreator {

    static ExecutorService service = Executors.newFixedThreadPool(5);

    static List list = new ArrayList();

    public static void main(String[] args) {
        service.execute(() -> execute()); //無(wú)返回值
        Future future = service.submit(() -> execute()); //有返回值
        list.add(future);
    }

    public static void execute() {
        //do something
    }
}

Empfohlene verwandte Artikel-Tutorials: Java-Schnellstart

Das obige ist der detaillierte Inhalt vonZusammenfassung zum Erstellen von Threads in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!