Java多線程的實現的四種方法，你都知道嗎

1.繼承Thread類，重寫run方法（其實Thread類本身也實現了Runnable接口）

2.實現Runnable接口，重寫run方法

3.實現Callable接口，重寫call方法（有返回值）

4.使用線程池（有返回值）

1.繼承Thread類，重寫run方法

每次創建一個新的線程，都要新建一個Thread子類的對象

啟動線程，new Thread子類（）.start（）

創建線程實際調用的是父類Thread空參的構造器

public class MyThread {

    public static void main(String ards[]){
        for(int i=0;i<10;i++){
            new ExtendsThread().start();
        }
        System.out.println(Thread.currentThread().getName());
    }
    
}

class ExtendsThread extends Thread{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

2.實現Runnable接口，重寫run方法

不論創建多少個線程，只需要創建一個Runnable接口實現類的對象

啟動線程，new Thread（Runnable接口實現類的對象）.start()

創建線程調用的是Thread類Runable類型參數的構造器

public class MyThread {

    public static void main(String ards[]){
        Runnable implRunnable = new ImplRunnable();
        for(int i=0;i<10;i++){
            new Thread(implRunnable).start();
        }
        System.out.println(Thread.currentThread().getName());
    }
    
}

class ImplRunnable implements Runnable{
    private volatile  int i = 0;
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"--"+ i++);
        
    }
}

3.實現Callable接口，重寫call方法（有返回值）

自定義類實現Callable接口時，必須指定泛型，該泛型即返回值的類型

每次創建一個新的線程，都要創建一個新的Callable接口的實現類、

如何啟動線程？

（1）創建一個Callable接口的實現類的對象

（2）創建一個FutureTask對象，傳入Callable類型的參數

public FutureTask(Callable<V>callable){……}

（3）調用Thread類重載的參數為Runnable的構造器創建Thread對象

將FutureTask作為參數傳遞

public class FutureTask<V>implements RunnableFuture<V>

public interface RunnableFuture<V>extends Runnable,Future<V>

如何獲取返回值？

調用FutureTask類的get()方法

public class MyThread {

    public static void main(String ards[]) throws InterruptedException, ExecutionException{

        for(int i=0;i<10;i++){
            Callable<Integer> implCallable = new ImplCallable();
            FutureTask<Integer> futureTask = new FutureTask<Integer>(implCallable);
            new Thread(futureTask).start();
            System.out.println(Thread.currentThread().getName()+"----"+futureTask.get());
        }

        System.out.println(Thread.currentThread().getName());
    }
    
}

class ImplCallable implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        int result = 0;
        for(int i=0;i<10;i++){
            result += i;
        }
        System.out.println(Thread.currentThread().getName());
        return result;
    }

}

4.線程池

Executors類

/**
 *
 * 線程池
 * 跟數據庫連接池類似
 * 避免了線程的創建和銷毀造成的額外開銷
 *
 * java.util.concurrent
 *
 * Executor    負責現成的使用和調度的根接口
 *    |--ExecutorService    線程池的主要接口
 *          |--ThreadPoolExecutor    線程池的實現類
 *          |--ScheduledExecutorService    接口，負責線程的調度
 *              |--ScheduledThreadPoolExecutor    (extends ThreadPoolExecutor implements ScheduledExecutorService)
 *
 *
 * Executors工具類
 * 提供了創建線程池的方法
 *
 */
public class ThreadPool {
    public static void main(String[] args){

        //使用Executors工具類中的方法創建線程池
        ExecutorService pool = Executors.newFixedThreadPool(5);

        ThreadPoolDemo demo = new ThreadPoolDemo();

        //為線程池中的線程分配任務,使用submit方法，傳入的參數可以是Runnable的實現類，也可以是Callable的實現類
        for(int i=1;i<=5;i++){
            pool.submit(demo);
        }

        //關閉線程池
        //shutdown ： 以一種平和的方式關閉線程池，在關閉線程池之前，會等待線程池中的所有的任務都結束，不在接受新任務
        //shutdownNow ： 立即關閉線程池
        pool.shutdown();


    }
}
class ThreadPoolDemo implements Runnable{

    /**多線程的共享數據*/
    private int i = 0;

    @Override
    public void run() {
        while(i<=50){
            System.out.println(Thread.currentThread().getName()+"---"+ i++);
        }
    }
}

public class ThreadPool2 {
    
    public static void main(String args[]){
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        
        for(int i=0;i<5;i++){
            Future<Integer> future = executorService.submit(new Callable<Integer>() {

                @Override
                public Integer call() throws Exception {
                    int result = 0;
                    for(int i=0;i<=10;i++){
                        result += i;
                    }
                    return result;
                }
            });
            
            try {
                System.out.println(Thread.currentThread().getName()+"--"+future.get());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }
        
        executorService.shutdown();

    }

}

Java多線程視頻教程：http://www.dabaquan.cn/javavideo/188.html

以上就是對“Java多線程的實現的四種方法，你都知道嗎”的介紹，希望對大家有所幫助，如有疑問，請在線咨詢，有專業老師隨時為你服務。