2. 程式人生 > >多執行緒（一）

多執行緒（一）

阿新 • • 發佈：2018-12-20

多執行緒是指的是這個程式（一個程序）執行時產生了不止一個執行緒。 並行與併發區別： 並行：多個cpu例項或者多臺機器同時執行一段處理邏輯，是真正的同時。 併發：通過cpu排程演算法，讓使用者看上去同時執行，實際上從cpu操作層面不是真正的同時。併發往往在場景中有公用的資源，那麼針對這個公用的資源往往產生瓶頸，我們會用TPS或者QPS來反應這個系統的處理能力。

Java執行緒具有五種基本狀態

新建狀態（New）：當執行緒物件對建立後，即進入了新建狀態，如：Thread t = new MyThread(); 就緒狀態（Runnable）：當呼叫執行緒物件的start()方法（t.start();），執行緒即進入就緒狀態。處於就緒狀態的執行緒，只是說明此執行緒已經做好了準備，隨時等待CPU排程執行，並不是說執行了t.start()此執行緒立即就會執行； 執行狀態（Running）：當CPU開始排程處於就緒狀態的執行緒時，此時執行緒才得以真正執行，即進入到執行狀態。注：就緒狀態是進入到執行狀態的唯一入口，也就是說，執行緒要想進入執行狀態執行，首先必須處於就緒狀態中； 阻塞狀態（Blocked）：處於執行狀態中的執行緒由於某種原因，暫時放棄對CPU的使用權，停止執行，此時進入阻塞狀態，直到其進入到就緒狀態，才有機會再次被CPU呼叫以進入到執行狀態。根據阻塞產生的原因不同，阻塞狀態又可以分為三種： 1.等待阻塞：執行狀態中的執行緒執行wait()方法，使本執行緒進入到等待阻塞狀態。 2.同步阻塞 -- 執行緒在獲取synchronized同步鎖失敗(因為鎖被其它執行緒所佔用)，它會進入同步阻塞狀態； 3.其他阻塞 -- 通過呼叫執行緒的sleep()或join()或發出了I/O請求時，執行緒會進入到阻塞狀態。當sleep()狀態超時、join()等待執行緒終止或者超時、或者I/O處理完畢時，執行緒重新轉入就緒狀態。 死亡狀態（Dead）：執行緒執行完了或者因異常退出了run()方法，該執行緒結束生命週期。

執行緒實現的兩種方式： 1、繼承Thread類

2、實現Runnable介面

public class Thread1 extends Thread {
private String name;

public Thread1(String name) {
this.name = name;
}

public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(name + "執行 : " + i);
}
}

public static void main(String[] args) {
　　Thread1 mTh1 = new Thread1("A");
　　Thread1 mTh2 = new Thread1("B");
　　mTh1.start();
　　mTh2.start();
}

}
 
public class Thread2 implements Runnable{
private String name;
 
public Thread2(String name) {
this.name=name;
}
 
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(name + "執行 : " + i);
try {
Thread.sleep((int) Math.random() * 10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
 
}
public static void main(String args[]) {
 
　　Thread2 th1 =new Thread2("A");
　　new Thread(th1).start();
　　Thread2 th2 =new Thread2("B");
　　new Thread(th2).start();
}
}

PS：Runnable沒有start()方法，所以需要new Thread來進行實現。Thread類也是實現Runnable介面

join（）使用方法

public class Thread1 extends Thread {
    private String name;

    public Thread1(String name) {
        this.name = name;
    }

    public void run() {
        System.out.println(Thread.currentThread().getName() + "執行緒執行開始!");
        for (int i = 0; i < 5; i++) {
            System.out.println("子執行緒" + name + "執行 : " + i);
            if (i == 2) {
                yield();
            }
        }
        System.out.println(Thread.currentThread().getName() + "執行緒執行結束!");
    }

    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName() + "主執行緒執行開始!");
        Thread1 mTh1 = new Thread1("A");
        Thread1 mTh2 = new Thread1("B");
        mTh1.start();
        mTh2.start();
        try {
            mTh1.join();//其他執行緒等待該執行緒執行完畢
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try {
            mTh2.join(); //其他執行緒等待該執行緒執行完畢
} catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "主執行緒執行結束!"); } }

ps: join()的作用是“等待該執行緒終止”，是指的主執行緒等待子執行緒的終止。子執行緒在呼叫了join()方法後面的程式碼，只有等到子執行緒結束了才能執行。不使用join()方法，主執行緒會比子執行緒結束。

執行緒池：ExecutorService 

ExecutorService 執行緒池是為解決迴圈new Thread()的問題，提供定時執行、定期執行、單執行緒、併發數控制等功能。

ExecutorService 提供了四種方法。

newCachedThreadPool是建立一個可快取執行緒池，如果執行緒池長度超過處理需要，可靈活回收空閒執行緒，若無可回收，則新建執行緒。

執行緒池為無限大，當執行第二個任務時第一個任務已經完成，會複用執行第一個任務的執行緒，而不用每次新建執行緒。

public static void main(String args[]) {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            cachedThreadPool.execute(new Runnable() {

                @Override
                public void run() {
                    System.out.println(index);
                }
            });
        }
    }

newFixedThreadPool是建立一個定長執行緒池，可控制執行緒最大併發數，超出的執行緒會在佇列中等待。所以每一次併發執行3個執行緒。

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 10; i++) {
            final int index = i;
            fixedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println(index);
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            });
        }
    }

newScheduledThreadPool建立一個定長執行緒池，支援定時及週期性任務執行。表示延遲3秒執行。

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        System.out.println("delay 3 seconds");
        for (int i = 0; i < 10; i++) {
            final int index = i;
            scheduledThreadPool.schedule(new Runnable() {

                @Override
                public void run() {
                    System.out.println(index);

                }
            }, 3, TimeUnit.SECONDS);
        }
    }
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        System.out.println("delay 3 seconds");
        for (int i = 0; i < 10; i++) {
            final int index = i;
            scheduledThreadPool.scheduleAtFixedRate(new Runnable() {

                @Override
                public void run() {
                    System.out.println(index);

                }
            }, 1, 3, TimeUnit.SECONDS);
        }
    }

表示延遲1秒後每3秒執行一次。

建立一個單執行緒化的執行緒池，它只會用唯一的工作執行緒來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先順序)執行。

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            singleThreadExecutor.execute(new Runnable() {

                @Override
                public void run() {
                        System.out.println(index);
                   
                }
            });
        }
    }

Callable、Future和FutureTask

Callable是介面，能夠返回執行結果，Future是介面,FutureTask實現方法。

public class FutureExample {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Date date1 = new Date();
        //同時可以併發執行5個執行緒
        ExecutorService pool = Executors.newFixedThreadPool(5);
        //建立結果集
        List<Future> list = new ArrayList<Future>();
        for (int i = 0; i < 100; i++) {
            Callable c = new MyCallable(i + " ");
            //執行執行緒提交
            Future f = pool.submit(c);
            list.add(f);
        }
        pool.shutdown();
        //將結果放回list，然後遍歷
        for (Future f : list) {
            System.out.println(">>>" + f.get().toString());
        }

        Date date2 = new Date();
        System.out.println((date2.getTime() - date1.getTime()) );
    }
}

class MyCallable implements Callable<Object> {
    private String taskNum;

    MyCallable(String taskNum) {
        this.taskNum = taskNum;
    }

    public Object call() throws Exception {
        System.out.println(">>>" + taskNum);
        Date dateTmp1 = new Date();
        Thread.sleep(1000);
        Date dateTmp2 = new Date();
        long time = dateTmp2.getTime() - dateTmp1.getTime();
        System.out.println(">>>" + taskNum);
        return taskNum + time;
    }
}
public class FutureExample {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Date date1 = new Date();
        //同時可以併發執行5個執行緒
        ExecutorService pool = Executors.newFixedThreadPool(5);
        //建立結果集
//        List<Future> list = new ArrayList<Future>();
        for (int i = 0; i < 100; i++) {
            Callable c = new MyCallable(i + " ");
            //執行執行緒提交
            Future f = pool.submit(c);
            System.out.println(">>>" + f.get().toString());//返回結果線上程裡面呼叫
        }
        pool.shutdown();
//        //將結果放回list，然後遍歷
//        for (Future f : list) {
//            System.out.println(">>>" + f.get().toString());
//        }

        Date date2 = new Date();
        System.out.println((date2.getTime() - date1.getTime()) );
    }
}

class MyCallable implements Callable<Object> {
    private String taskNum;

    MyCallable(String taskNum) {
        this.taskNum = taskNum;
    }

    public Object call() throws Exception {
        System.out.println(">>>" + taskNum);
        Date dateTmp1 = new Date();
        Thread.sleep(1000);
        Date dateTmp2 = new Date();
        long time = dateTmp2.getTime() - dateTmp1.getTime();
        System.out.println(">>>" + taskNum);
        return taskNum + time;
    }
}
public class FutureTaskExample {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Date date1 = new Date();
        //同時可以併發執行5個執行緒
        ExecutorService pool = Executors.newFixedThreadPool(100);
        //建立結果集
//        List<Future> list = new ArrayList<Future>();
        for (int i = 0; i < 100; i++) {
            Callable c = new MyCallable(i + " ");
            //執行執行緒提交
//            Future f = pool.submit(c);
             //建立FutureTask  
            FutureTask<Object> futureTask=new FutureTask<Object>(c);  
            pool.submit(futureTask);
            System.out.println(">>>" + futureTask.get().toString());//返回結果線上程裡面呼叫
        }
        pool.shutdown();
//        //將結果放回list，然後遍歷
//        for (Future f : list) {
//            System.out.println(">>>" + f.get().toString());
//        }

        Date date2 = new Date();
        System.out.println((date2.getTime() - date1.getTime()) );
    }
}

class MyCallable implements Callable<Object> {
    private String taskNum;

    MyCallable(String taskNum) {
        this.taskNum = taskNum;
    }

    public Object call() throws Exception {
        System.out.println(">>>" + taskNum);
        Date dateTmp1 = new Date();
        Thread.sleep(1000);
        Date dateTmp2 = new Date();
        long time = dateTmp2.getTime() - dateTmp1.getTime();
        System.out.println(">>>" + taskNum);
        return taskNum + time;
    }
}

相關推薦

Java多執行緒（一）基礎

1.關於執行緒與程序的區別：執行緒指程序中的一個執行場景，也就是執行流程，同一個程序中的執行緒共享其程序中的記憶體和資源（共享的記憶體是堆記憶體和方法區記憶體，棧記憶體不共享，每個執行緒有自己的，一個執行緒一個棧。）；每個程序是一個應用程式，都有獨立的記憶體空間。多執行緒的使用是為了提高程式

Java 多執行緒（一）—— 概念的引入

　　併發和並行 　　 　　程序和執行緒 　　 　　如何建立多執行緒 　　 　　第一種方法：繼承 Thread 類 　　 　　第二種方法：實現 Runnable 介面 　　 　　第三種方法：使用匿名內部類建立執行緒 　　 　　正文 　　 　　回到頂部 　　 　　併發和並行 　　 　　並行：指兩個或多個

深入理解Java多執行緒（一）

關於java多執行緒的概念以及基本用法：java多執行緒基礎 1，停止執行緒 停止執行緒意味著線上程執行完之前停止正在做的操作，即立刻放棄當前的操作，這並不容易。停止執行緒可以用Thread.stop()方法，但是這個方法不安全，所以不建議使用，還有一個方法就是Thre

Java多執行緒（一） 什麼是執行緒

宣告：本系列大多是翻譯自https://www.javatpoint.com，加上自己的增刪改，盡力寫的系統而通俗易懂，後文不再重複宣告。 java的多執行緒是一個同時執行多個執行緒的過程。 執行緒是一個輕量級的子程序，是最小的處理單元。多執行緒和多程序都用於實現多工處理。 但是，我們使用多執

java多執行緒（一）:執行緒的五種基本狀態以及生命週期

1、Java執行緒具有五中基本狀態： 新建狀態（New）：當執行緒物件對建立後，即進入了新建狀態，如：Thread thread1 = new MyThread(); 就緒狀態（Runnable）：當呼叫執行緒物件的start()方法[ 如:thread1 .start(); ]，執行緒

11 非同步多執行緒（一）

任何的非同步多執行緒，都是和委託相關，沒有委託，啥也沒有。 BeginInvoke在 C#裡面，就是啟動一個執行緒完成任務。 用設定斷點的方法來除錯的非同步多執行緒，是行不通的，只有多寫一些日誌或者輸出文字資訊到控制檯程式上。 如果要想看到控制檯程式一樣的介面輸出結果，

淺解多執行緒（一）

多執行緒的相關概念 1.程序：是作業系統結構的基礎；是一個正在執行的程式；計算機中正在執行的程式例項；可以分配給處理器並由處理器執行的一個實體；由單一順序的執行顯示，一個當前狀態和一組相關的系統資源所描述的活動單元。 2.執行緒：執行緒是程式中一個單一的順序控

結合生活，剖析《生產者消費者模型》-java多執行緒（一）

　　部落格園的園友們好，看部落格園上各位大佬的文章，已陪伴了我程式設計師職業的三年， 如今自己同樣希望能把自己從小白到菜鳥的成長過程分享給大家。不定期更新！！！ 首先我本人智商不高，理解問題十分吃力，完全不屬於天才的行列，因此學習每一個知識 都喜歡刨根問底，結合生活，徹徹底底理解知識的本質！ 進入正題，這篇文

Java多執行緒（一）：執行緒基礎及建立

（一）、執行緒的生命週期 新建狀態: 使用 new 關鍵字和 Thread 類或其子類建立一個執行緒物件後，該執行緒物件就處於新建狀態。它保持這個狀態直到程式 start() 這個執行緒。 就緒狀態: 當執行緒物件呼叫了start()方法之後，該執行緒就進入就緒

多執行緒（一）ThreadLocal 執行緒內資料共享

每個執行緒單獨一份資料ThreadLocal   import java.util.Random; public class D { // public static ThreadLocal<Integer> map=new ThreadLocal<Intege

多執行緒（一）基礎部分

多執行緒基礎 執行緒釋義 計算機採用多工設計，每個任務對應一個程序。例如執行 中的qq.exe對應作業系統中的一個程序。程序的特點是： 程序是系統執行的基本單位 每個程序有自己獨立的記憶體空間、系統資源 每個程序的內部資料和狀態是完全獨立的。 一個程序，可以

多執行緒（一）

多執行緒是指的是這個程式（一個程序）執行時產生了不止一個執行緒。 並行與併發區別： 並行：多個cpu例項或者多臺機器同時執行一段處理邏輯，是真正的同時。 併發：通過cpu排程演算法，讓使用者看上去同時執行，實際上從cpu操作層面不是真正的同時。併發往往在場景中有公用的資源，那

深入理解多執行緒（一）——Synchronized的實現原理

synchronized，是Java中用於解決併發情況下資料同步訪問的一個很重要的關鍵字。當我們想要保證一個共享資源在同一時間只會被一個執行緒訪問到時，我們可以在程式碼中使用synchronized關鍵字對類或者物件加鎖。那麼，本文來介紹一下synchronized關鍵字的實

瘋狂java講義：多執行緒（一）

第十六章  多執行緒（一）     並行：在同一時刻，有多條指令在多個處理器上同時執行     併發：同一時刻只有一個指令被處理器執行，但多個程序指令快速輪換執行，使得巨集觀好像多個指令在同時執行     作業系統可以同時執行多個任務，每個任務就是程序；程序可以

JAVA基礎22-多執行緒（一）【多執行緒的概念，執行緒狀態及其轉換】

多執行緒 一.概念          1. 程序：程序是表示資源分配的的基本概念，又是排程執行的基本單位，是系統中的併發執行的單位。           2. 執行緒：單個程序中執行中

Java5 多執行緒（一）入門篇

首先回顧一下JDK1.5之前的執行緒相關的知識:1 執行緒的入門.        什麼是執行緒,執行緒就是程式執行的線索,Java是面向物件的語言什麼類來表示這樣一個東西呢?Thread.通過start()方法啟動它,執行緒所要執行的任務放在run()方法裡面,下面可以看一下

多程序與多執行緒（一）--基本概念(轉)

程序（英語：Process，中國大陸譯作程序，臺灣譯作行程） 是具有一定獨立功能的程式關於某個資料集合上的一次執行活動，是系統進行資源分配和排程的一個獨立單位。程式是一組指令的有序集合，它本身沒有任何執行的含義，只是一個靜態實體。程序是程式在某個資料集上的執行，是一個動態實體（程序本身不會執行，是執行緒的容器

理解多執行緒（一）

引入併發概念 單道作業系統 其實在單道系統時期，是沒有併發的，cpu更是沒有多核。程式設計師輸入資料，計算機處理，計算機輸出結果，每次一個程式執行完才能執行其他程式。但不久聰明的程式設計師們發現這樣極大的浪費計算機資源。比如，在執行一個算術問題時候，程式設計師輸入資料是很慢的(sca

Java多執行緒（一） —— 執行緒的狀態詳解

一、多執行緒概述  1、 程序 是一個正在執行的程式。是程式在計算機上的一次執行活動。 每一個程序執行都有一個執行順序。該順序是一個執行路徑，或者叫一個控制單元。 系統以程序為基本單位進行系統資源的排程和分配。程式要執行，系統就在記憶體中為該程式分配一塊獨立的記憶體空間，載入程式程式碼和資源進行執行。 程式

java基礎的核心技術：多執行緒（一）

1、程式、程序、執行緒的概念 2、java中多執行緒的建立和使用(重點) 2.1、繼承Thread類與實現Runnable介面 2.2、Thread類的主要方法 2.3、執行緒的排程與設定優先順序 3、執行緒的生命週期 4、執行緒的同步(重點) 5、執行緒的通訊  ---