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();

    }

}