一、并發程式設計簡介

1、基礎概念

程式

與計算機系統操作有關的計算機程式、規程、規則，以及可能有的檔案、文檔及資料。

程序

程序是計算機中的程式，關于某資料集合上的一次運作活動，是系統進行資源配置設定和排程的基本機關，是作業系統結構的基礎。在早期面向程序設計的計算機結構中，程序是程式的基本執行實體；在面向線程設計的計算機結構中，程序是線程的容器。程式是指令、資料及其組織形式的描述，程序是程式的實體。

線程

線程是作業系統能夠進行運算排程的最小機關，包含在程序之中，是程序中的實際運作機關。一條線程指的是程序中一個單一順序的控制流，一個程序中可以并發多個線程，每條線程并行執行不同的任務。

順序程式設計

程式中的所有步驟在任意時刻隻能執行一個步驟。程式設計中絕大部分場景都是基于順序程式設計。

并發程式設計

在一台處理器上“同時”處理多個任務，并行處理程式中的複雜耗時任務。并發是在同一實體上的多個事件。多個事件在同一時間間隔發生。

2、入門案例

public class HelloThread {
    public static void main(String[] args) {
        System.out.println("Hello,Thread");
        // 目前線程名稱
        System.out.println(Thread.currentThread().getName());
        // 線程系統的管理接口
        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
        long[] threadIds = threadMXBean.getAllThreadIds() ;
        for (long id : threadIds) {
            ThreadInfo threadInfo = threadMXBean.getThreadInfo(id) ;
            System.out.println(threadInfo.getThreadId()+
                    ":"+threadInfo.getThreadName());
        }
    }
}

列印結果：

5:Monitor Ctrl-Break
4:Signal Dispatcher
3:Finalizer
2:Reference Handler
1:main

由此可知上述一段簡單的Java程式，不止一條main線程在執行。

二、線程建立方式

1、繼承Thread類

Thread類的基礎結構：

class Thread implements Runnable

這裡已經實作了Runnable接口。

public class CreateThread01 {
    public static void main(String[] args) {
        // 調用方法
        MyThread1 myThread1 = new MyThread1() ;
        myThread1.start();
    }
}
class MyThread1 extends Thread {
    // 設定線程名稱
    public MyThread1 (){
        super("CicadaThread");
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

2、實作Runnable接口

如果建立的線程類已經存在父類，則不能再繼承Thread類，在Java中不允許多繼承，這時就可以實作Runnable接口。

public class CreateThread02 {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyThread2(),"MyThread2") ;
        thread.start();
    }
}
class MyThread2 implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+" run ...");
    }
}

3、匿名内部類

在一個類裡面定義一個類，稱為内部類。内部類就相當于外部類的一個成員，可以把内部類看成一個整體。

public class CreateThread03 {
    public static void main(String[] args) {
        //方式1
        new Thread("ThreadName1") {
            public void run() {
                System.out.println("1:"+Thread.currentThread().getName());
            };
        }.start();

        //方式2
        new Thread(new Runnable() {
            public void run() {
                System.out.println("2:"+Thread.currentThread().getName());
            }
        },"ThreadName2"){
            // 這裡重寫了run方法
            @Override
            public void run() {
                System.out.println("3:"+Thread.currentThread().getName());
            }
        }.start();
    }
}

4、傳回值線程

顧名思義，該線程線程異步執行後，可以傳回線程的處理結果。

public class CreateThread04 {
    public static void main(String[] args) throws Exception {
        MyThread4 myThread4 = new MyThread4();
        FutureTask<Integer> task = new FutureTask<>(myThread4);
        Thread thread = new Thread(task,"TaskThread");
        thread.start();
        // 等待擷取結果
        // Integer result = task.get();
        // 設定擷取結果的等待時間，逾時抛出：TimeoutException
        Integer result = task.get(3, TimeUnit.SECONDS) ;
        System.out.println("result="+result);
    }
}
class MyThread4 implements Callable<Integer> {
    // 封裝線程執行的任務
    @Override
    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName());
        Thread.sleep(1000);
        return 2+3;
    }
}

5、定時任務

Timer是背景線程執行任務排程的工具類，可以根據規則配置定期執行或者重複執行。

class TimerTask implements Runnable

任務類：TimerTask結構實作Runnable接口。

public class CreateThread05 {
    public static void main(String[] args) {
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("延遲1s,每隔3s執行一次");
            }
        }, 1000, 3000);
    }
}

6、線程池管理

線程池是一種多線程處理形式，處理過程中将任務添加到隊列，然後在建立線程後自動啟動這些任務。

public class CreateThread06 {
    public static void main(String[] args) {
        Executor threadPool = Executors.newFixedThreadPool(5);
        for(int i = 0 ;i < 5 ; i++) {
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }
            });
        }
    }
}

三、線程狀态管理

1、狀态描述

初始狀态：建構線程執行個體後，調用start()方法啟動前，處于該狀态。

RUNNABLE

運作狀态：在Java線程中，就緒和運作兩個狀态稱作運作狀态，在實際的執行過程中，這兩個狀态是随時可能切換的。啟動start()方法被調用，或者sleep()後，join()結束等，就進入RUNNABLE就緒狀态，開始等待CPU時間片；線程排程選中該線程、并配置設定了CPU時間片後，該線程盡管處于Runnable狀态，就是運作狀态(Running)；

BLOCKED

阻塞狀态：通常指被鎖機制阻塞，表示線程正在擷取有鎖控制的資源。

WAITING

等待狀态：進入該狀态的線程，等待被其他線程發出通知或中斷，也稱顯式喚醒。

TIMED_WAITING

逾時等待狀态：該狀态不同于WAITING狀态，該狀态的線程可以在指定的時間後自動喚醒；

TERMINATED

終止狀态：表示目前線程任務執行完畢。

2、案例流程分析

public class StateCycle01 {
    public static void main(String[] args) throws Exception {
        // 進入初始狀态
        StateThread01 stateThread01 = new StateThread01();
        FutureTask<String> task = new FutureTask<>(stateThread01);
        Thread thread = new Thread(task,"GetValueThread");
        // 運作狀态
        thread.start();
        // 逾時等待結果
        String result = task.get(3, TimeUnit.SECONDS) ;
        System.out.println("result="+result);

        StateThread02 stateThread02 = new StateThread02() ;
        Thread thread1 = new Thread(stateThread02,"WaitThread");
        thread1.start();
    }
}
class StateThread01 implements Callable<String> {
    @Override
    public String call() throws Exception {
        // 逾時等待
        Thread.sleep(1000);
        return "Hello,Cicada";
    }
}
class StateThread02 implements Runnable {
    @Override
    public void run() {
        synchronized (StateCycle01.class) {
            System.out.println("進入線程...");
            try {
                // 等待狀态，放棄對象鎖
                StateCycle01.class.wait(2000);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("線程繼續...");
        }
    }
}

上述流程描述了線程不同狀态之間的切換，基本流程圖如下。

線程的狀态描述起來不算複雜，但是每個狀态間的切換，是非常的複雜，後續會分子產品單個解釋。

四、優缺點總結

1、優點說明

最直接作用使程式執行的效率大幅度提升;程式異步解耦，在web開發中，經常有後續的程式要執行，有需要快速的使用者界面響應；當然熟練使用并發程式設計，也是一個優秀程式員必備技能。

2、缺點分析

并發程式設計學習的曲線非常陡峭，難度較大；多線程之間争搶資源容易出現問題；并不是線程越多，執行速度就越快，線程之前切換是耗時的，需要合理建立和使用鎖機制；線程建立和之間的通信需要很清晰的邏輯；線程死鎖問題更是無法完全避免的問題；是以在一般情況下公司對線程使用的規範是十分嚴格的。

五、源代碼位址

GitHub·位址
https://github.com/cicadasmile/java-base-parent
GitEE·位址
https://gitee.com/cicadasmile/java-base-parent

Java并發程式設計(01)：線程的建立方式，狀态周期管理一、并發程式設計簡介二、線程建立方式三、線程狀态管理四、優缺點總結五、源代碼位址

一、并發程式設計簡介

1、基礎概念

2、入門案例

二、線程建立方式

1、繼承Thread類

2、實作Runnable接口

3、匿名内部類

4、傳回值線程

5、定時任務

6、線程池管理

三、線程狀态管理

1、狀态描述

2、案例流程分析

四、優缺點總結

1、優點說明

2、缺點分析

五、源代碼位址

繼續閱讀

Java小案例——随機數猜測随機數猜測

nginx location中斜線的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

面試題解析：你接口測試是怎麼做的？

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method