Java多線程的種類和區別

本篇內容主要講解“Java多線程的種類和區別”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“Java多線程的種類和區別”吧!

1.多線程種類和區別

Thread類、runnable接口、callable接口，使用callable時，需要重寫call方法，使用FutureTask調用，使用get方法可以獲取返回值。 Callable與Thread、Runnable最大的不同是Callable能返回一個異步處理的結果Future對象并能拋出異常，而其他兩種不能 runnable方式實現更為靈活，耦合度低，是比較常用的方式。面向接口編程也是設計模式六大原則的核心

package thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableModel<V> implements Callable<V> {

    @SuppressWarnings("unchecked")
    @Override
    public V call() throws Exception {
        // TODO Auto-generated method stub
        System.out.println("重寫call方法");
        return (V) "調用callable，有返回值";
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        FutureTask<String> futureTask = new FutureTask<>(
                new CallableModel<String>());
        Thread thread = new Thread(futureTask);
        thread.start();
        System.out.println(futureTask.get());
    }
}

2.多線程的好處

發揮多核CPU的優勢，放置阻塞，方便建模等

3.start和run的區別 只有調用start才會表現出多線程特點。run只是一個普通方法，調用時多個線程會同步執行。

3.start和run的區別 只有調用start才會表現出多線程特點。run只是一個普通方法，調用時多個線程會同步執行。

4.runnable和callable的區別 callable可以和Future、FutureTask配合可以用來獲取異步執行的結果，call方法是有返回值的，多線程充滿未知性，使用futureTask來獲取執行結果，在等待太長時間未返回結果時取消此線程是非常有必要的

5.CyclicBarrier和CountDownLatch的區別-柵欄鎖 都在java.util.concurrent下，都可以用來表示代碼運行到某個點上，CyclicBarrier用于等待一組事件完成，然后啟動下一個事件，例如一組運動員準備好之后，發出跑的命令，CountDownLatch允許一個或者多個線程等待一組事件的產生。 1）CyclicBarrier的某個線程運行到某個點上之后，該線程即停止運行，直到所有的線程都到達了這個點，所有線程才重新運行；CountDownLatch則不是，某線程運行到某個點上之后，只是給某個數值-1而已，該線程繼續運行。

2）CyclicBarrier只能喚起一個任務，CountDownLatch可以喚起多個任務。

3）CyclicBarrier可重用(通過調用reset方法)，CountDownLatch不可重用，計數值為0該CountDownLatch就不可再用了。 6.CyclicBarrier代碼示例

package thread;

;

/**
 *     
 * 項目名稱：test  
 * 類名稱：ThreadModel   
 * 類描述：  通過集成Thread實現多線程
 * 創建人：@author 王豐生
 * 創建時間：2019年7月1日 下午1:00:46 
 * 修改人：@author 王豐生
 * 修改時間：2019年7月1日 下午1:00:46   
 * 修改備注：
 * @version     
 *
 */
public class ThreadModel extends Thread {
    private java.util.concurrent.CyclicBarrier cyclicBarrier;

    /**
     * Thread實際是實現了runnable接口的一個類，需要重寫run方法，調用start方法啟動
     */
    public ThreadModel(java.util.concurrent.CyclicBarrier cyclicBarrier) {
        // TODO Auto-generated constructor stub
        this.cyclicBarrier = cyclicBarrier;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        super.run();
        try {
            System.out.println(Thread.currentThread().getName() + "開始等待");
            cyclicBarrier.await();
            System.out.println(Thread.currentThread().getName() + "開始執行");
            Thread.sleep(1000 * 2);
            System.err.println(Thread.currentThread().getName() + "執行完畢");
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    public static void main(String[] args) {
        int threadCount = 3;
        java.util.concurrent.CyclicBarrier cyclicBarrier = new java.util.concurrent.CyclicBarrier(
                threadCount);
        for (int i = 0; i < threadCount; i++) {
            System.out.println("創建工作線程" + i);
            ThreadModel threadModel = new ThreadModel(cyclicBarrier);
            threadModel.start();
        }
    }
}

7.CountDownlatch代碼示例 主線程內啟動兩個線程之后，調用await方法，線程1執行完畢。調用countdown，線程2執行完畢調用countdown，代表線程都執行完，則釋放await的鎖，繼續向下執行

/**
 * 看大夫任務
 * Created by jiapeng on 2018/1/7.
 */
public class SeeDoctorTask implements Runnable{

    private CountDownLatch countDownLatch;

    public SeeDoctorTask(CountDownLatch countDownLatch){
        this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
        try {
            Thread.sleep(3000);
            System.out.println("看大夫成功，大夫給開了些藥單子");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if(countDownLatch != null) {
                countDownLatch.countDown();
            }
        }
    }
}

/**
 * 排隊的任務
 * Created by jiapeng on 2018/1/7.
 */
public class QueueTask implements Runnable{

    private CountDownLatch countDownLatch;

    public QueueTask(CountDownLatch countDownLatch){
        this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
        try {
            Thread.sleep(5000);
            System.out.println("排隊成功，可以開始交費");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if(countDownLatch != null) {
                countDownLatch.countDown();
            }
        }
    }
}

/**
 * 配媳婦去看病，輪到媳婦看大夫時
 * 我就開始去排隊準備交錢了。
 * Created by jiapeng on 2018/1/7.
 */
public class MainClient {
    public static void main(String[] args) throws Exception{
        long now = System.currentTimeMillis();
        CountDownLatch countDownLatch = new CountDownLatch(2);
        Executor executor = Executors.newFixedThreadPool(2);
        executor.execute(new SeeDoctorTask(countDownLatch));
        executor.execute(new QueueTask(countDownLatch));
        countDownLatch.await();
        System.out.println("over，回家 cost:"+(System.currentTimeMillis()-now));
    }
}

8.volatile關鍵字 volatile修飾的變量保證了其在多線程之內的可見性，相當于一個輕量級的sychronized，多線程讀到的此變量一定都是最新的。

9.什么是線程安全 多線程狀態下獲得和單線程下永遠能獲得同樣的結果，則代表是線程安全的，分為

10.獲取線程堆棧dump文件 死循環、死鎖、阻塞等問題，需要打印線程堆棧，可以使用getStackTrace()方法,使用jps獲取線程pid，用jstack pid命令，或者kill-3 pid來獲取線程堆棧信息

11.線程出現了異常 如果出現異常且未被捕獲，則線程會終止，如果這個線程持有某個某個對象的監視器，那么這個對象監視器會被立即釋放

到此，相信大家對“Java多線程的種類和區別”有了更深的了解，不妨來實際操作一番吧！這里是億速云網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！