常用語言的線程模型（Java、go、C++、python3）

背景知識

軟件是如何驅動硬件的？
硬件是需要相關的驅動程序才能執行，而驅動程序是安裝在操作系統內核中。如果寫了一個程序A，A程序想操作硬件工作，首先需要進行系統調用，由內核去找對應的驅動程序驅使硬件工作。而驅動程序怎麼讓硬件工作的呢？驅動程序作爲硬件和操作系統之間的媒介，可以把操作系統中相關的指令翻譯成硬件能夠識別的電信號，同時，驅動程序也可以將硬件的電信號轉爲操作系統能夠識別的指令。
進程、輕量級進程、線程關係
一個進程由於所運行的空間不同，被分爲內核線程和用戶進程，之所有稱之爲內核線程，是因爲其不擁有虛擬地址空間。如果創建一個新的用戶進程，會分配一個新的虛擬地址空間，不同用戶進程之間資源是隔離的。由於創建一個新的進程需要消耗很多的資源，並且在進程之間切換的代價也很昂貴，因此引入了輕量級進程。輕量級進行本質上也是對內核線程的高層抽象，雖然不同的輕量級進程之間可以共享某些資源，但由於輕量級進程本質上還是內核線程，如果進行輕量級線程之間的切換，需要進行系統調用，代價也是比較昂貴的。內核本質上只能感知到進程的存在，像不同語言的多線程技術，是在用戶進程的基礎上創建的線程庫，線程本身不參與處理器競爭，而是由其所屬的用戶進程參與處理器的競爭。
如何理解用戶態和內核態
首先我們需要理解到計算機資源是有限的，不管是CPU資源、內存資源、IO資源、網絡資源，爲了保證這些資源的合理利用，需要有一個管控機制，而這個管控機制都是交於操作系統來處理的。用戶態和內核態是操作系統的一種邏輯劃分，本質上是進行權限控制，處於用戶態的進程可以直接使用分配給其的內存空間，但如果想使用CPU等稀缺資源，處於用戶態的進程就沒有這個權限了，必須通過系統調用，讓當前進程進入內核態，這樣可以有更大的權限去申請CPU資源、內存資源、IO資源等；

操作系統線程模型

java語言

線程模型

在Java誕生之初，在Java中就引入了線程，最初稱之爲“綠色線程”，完全由JVM進行管理，這和操作系統用戶線程是多對一的實現，但隨着操作系統對線程支持越來越強大，java中的線程實現採用了一對一的實現，即一個java線程對應於一個操作系統用戶線程，但是這個線程的堆棧大小是固定的，隨着線程數量創建過多，可能導致內存溢出。在java19版本中引入了虛擬線程的概念，虛擬線程有一個動態的堆棧，可以增大和縮小，這和操作系統用戶線程之間是一個多對多的關係，隨着後面的發展，java中的線程模型會變得越來越強大。

優缺點

作爲一對一的線程模型維護起來比較簡單，但是由於每一個線程棧信息是固定的，不利於創建大量的線程，並且多線程操作時可能涉及頻繁的系統調用，上下文切換代價高。

使用方式(以生產者消費者模型來說明)

 public class ThreadTest {

    public static final Object P = new Object();

    static List<Integer> list = new ArrayList<>();

    @Test
    public void test() throws Exception {

        Thread thread1 = new Thread(()-> {
            while(true) {
                try {
                    product();
                }catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        Thread thread2 = new Thread(() -> {
            while(true) {
                try {
                    consume();
                }catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();
    }

    private static void product() throws Exception {
        synchronized (P) {
            if(list.size() == 1) {
                // 讓出鎖
                P.wait();
            }
            list.add(1);
            System.out.println("produce");
            P.notify();
        }
    }

    private static void consume() throws Exception {
        synchronized (P) {
            if(list.size() == 0) {
                P.wait();
            }
            list.remove(list.size() - 1);
            System.out.println("consume");
            P.notify();
        }
    }
}

go語言

go語言線程模型

在go語言中，線程模型就是比較強大了，包含了三個概念：內核線程（M）、goroutine(G)、G的上下文環境（P）。其中G表示基於協程創建的用戶線程，M直接關聯一個內核線程，P裏面一般存放正在運行的goroutine的上下文環境（函數指針、堆棧地址和地址邊界等）。

優缺點

go語言中的線程模型算是很強大了，引用了協程，線程棧大小可以動態調整，很好地避免了java中目前的線程模型缺點。

使用方式(以生產者消費者模型來說明)

package main

import (
	"fmt"
)

type ThreadTest struct {
	lock chan int
}

func (t *ThreadTest) produce() {
	for {
		t.lock <- 10
		fmt.Println("produce:", 10)
	}
}

func (t *ThreadTest) consume() {
	for {
		v := <-t.lock
		fmt.Println("consume:", v)
	}
}

func main() {
	maxLen := 10
	t := &ThreadTest{
		make(chan int, maxLen),
	}
	// 重點在這裏，開啓新的協程，配合通道，讓go的多線程變成非常優雅
	go t.consume()
	go t.produce()
	select {}

}

c++語言

c++語言線程模型

在c++11中增加了操作thread庫，提供對線程操作的進一步封裝，而這個庫底層是使用了pthread庫，這個庫底層採用了1:1線程模型，跟java中的線程模型類似。

優缺點

使用方式(以生產者消費者模型來說明)

#include 
#include 
#include 
#include  

static const int SIZE = 10;
static const int ITEM_SIZE = 30;

std::mutex mtx;

std::condition_variable not_full;
std::condition_variable not_empty;

int items[SIZE];

static std::size_t r_idx = 0;
static std::size_t w_idx = 0;

void produce(int i) {
    std::unique_lock lck(mtx);
    while((w_idx+ 1) % SIZE == r_idx) {
        std::cout << "隊列滿了" << std::endl;
        not_full.wait(lck);
    }
    items[w_idx] = i;
    w_idx = (w_idx+ 1) % SIZE;
    not_empty.notify_all();
    lck.unlock();
}

int consume() {
    int data;
    std::unique_lock lck(mtx);
    while(w_idx == r_idx) {
        std::cout << "隊列爲空" << std::endl;
        not_empty.wait(lck);
    }
    data = items[r_idx];
    r_idx = (r_idx + 1) % SIZE;
    not_full.notify_all();
    lck.unlock();
    return data;
}

void p_t() {
    for(int i = 0; i < ITEM_SIZE; i++) {
        produce(i);
    }
}

void c_t() {
    static int cnt = 0;
    while(1) {
        int item = consume();
        std::cout << "消費第" << item << "個商品" << std::endl;
        if(++cnt == ITEM_SIZE) {
            break;
        }
    }
}

int main() {
    std::thread producer(p_t);
    std::thread consumer(c_t);
    producer.join();
    consumer.join();
}

python語言

python線程模型

python中的線程使用了操作系統的原生線程，python虛擬機使用了一個全局互斥鎖（GIL）來互斥線程對Python虛擬機的使用，當一個線程獲取GIL的權限之後，其他的線程必須等待這個線程釋放GIL鎖，索引再多核CPU上，python多線程也會退化爲單線程，無法利用多核的優勢。

優缺點

python語言多線程由於GIL的存在，在計算密集型場景上，很難體現到優勢，並且由於涉及線程切換的代碼，反而可能性能還不如單線程好。

使用方式(以生產者消費者模型來說明)

#! /usr/bin/python3

import threading
import random
import time

total = 100
lock = threading.Lock()
totalTime = 10
gTime = 0

class Consumer(threading.Thread):
        def run(self):
                global total
                global gTime
                while True:
                        cur = random.randint(10, 100)
                        lock.acquire()
                        if total >= cur:
                                total -= cur
                                print("{}使用了{}, 當前剩餘{}".format(threading.current_thread(), cur, total))
                        else:
                            print("{}準備使用{}，當前剩餘{}，不足，不能消費".format(threading.current_thread(), cur, total))
                        if gTime == totalTime:
                               lock.release()
                               break
                        lock.release()
                        time.sleep(0.7)

class Producer(threading.Thread):
    def run(self):
           global total
           global gTime
           while True:
                  cur = random.randint(10, 100)
                  lock.acquire()
                  if gTime == totalTime:
                         lock.release()
                         break
                  total += cur
                  print("{}生產了{}, 剩餘{}".format(threading.current_thread(), cur, total))
                  gTime+= 1
                  lock.release()
                  time.sleep(0.5)
if __name__ == '__main__':
       t1 = Producer(name="生產者")
       t1.start()
       t2 = Consumer(name="消費者")
       t2.start()

總結

在目前的線程模型中，有1:1、M:1、M:N多種線程模型，具體採用哪種線程模型也和硬件和操作系統的支持程度有關，像誕生比較早的語言，普通採用M:1、1:1線程模型，像c++、java。而新誕生不久的go語言，採用的是M:N線程模型，在多線程的支持上更加強大。

感覺瞭解一下線程模型還是很有必要的，如果不清楚語言層面上的線程在操作系統層面怎麼映射使用，在使用過程中就會不清不楚，可能會踩一些坑，我們都知道在java中不同無限的創建線程，這會導致內存溢出，go語言中對多線程支持更加強大，很多事情不需要我們再去關注了，在語言底層已經幫助我們做了。

每種語言的底層細節太多了，如果想深入研究某一個技術，還是得花精力去研究。

作者：京東零售姜昌偉

來源：京東雲開發者社區

常用語言的線程模型（Java、go、C++、python3） | 京東雲技術團隊

背景知識

操作系統線程模型

java語言

線程模型

優缺點

使用方式(以生產者消費者模型來說明)

go語言

go語言線程模型

優缺點

使用方式(以生產者消費者模型來說明)

c++語言

c++語言線程模型

優缺點

使用方式(以生產者消費者模型來說明)

python語言

python線程模型

優缺點

使用方式(以生產者消費者模型來說明)

總結

哈哈哈哈或

【自用】關於微信小程序的合法域名列表，

使用 @NoRepositoryBean 簡化數據庫訪問

MySQL查出時間比實際晚8小時的解決方案

什麼是IPD項目管理模式？聊聊IPD下的產品研發流程

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結