经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » C++ » 查看文章
常用语言的线程模型（Java、go、C++、python3）
来源：cnblogs　　作者：京东云开发者　　时间：2023/7/17 9:40:45　　对本文有异议

背景知识

  1. 软件是如何驱动硬件的？
    硬件是需要相关的驱动程序才能执行，而驱动程序是安装在操作系统内核中。如果写了一个程序A，A程序想操作硬件工作，首先需要进行系统调用，由内核去找对应的驱动程序驱使硬件工作。而驱动程序怎么让硬件工作的呢？驱动程序作为硬件和操作系统之间的媒介，可以把操作系统中相关的指令翻译成硬件能够识别的电信号，同时，驱动程序也可以将硬件的电信号转为操作系统能够识别的指令。
  2. 进程、轻量级进程、线程关系
    一个进程由于所运行的空间不同，被分为内核线程和用户进程，之所有称之为内核线程，是因为其不拥有虚拟地址空间。如果创建一个新的用户进程，会分配一个新的虚拟地址空间，不同用户进程之间资源是隔离的。由于创建一个新的进程需要消耗很多的资源，并且在进程之间切换的代价也很昂贵，因此引入了轻量级进程。轻量级进行本质上也是对内核线程的高层抽象，虽然不同的轻量级进程之间可以共享某些资源，但由于轻量级进程本质上还是内核线程，如果进行轻量级线程之间的切换，需要进行系统调用，代价也是比较昂贵的。内核本质上只能感知到进程的存在，像不同语言的多线程技术，是在用户进程的基础上创建的线程库，线程本身不参与处理器竞争，而是由其所属的用户进程参与处理器的竞争。
  3. 如何理解用户态和内核态
    首先我们需要理解到计算机资源是有限的，不管是CPU资源、内存资源、IO资源、网络资源，为了保证这些资源的合理利用，需要有一个管控机制，而这个管控机制都是交于操作系统来处理的。用户态和内核态是操作系统的一种逻辑划分，本质上是进行权限控制，处于用户态的进程可以直接使用分配给其的内存空间，但如果想使用CPU等稀缺资源，处于用户态的进程就没有这个权限了，必须通过系统调用，让当前进程进入内核态，这样可以有更大的权限去申请CPU资源、内存资源、IO资源等；

操作系统线程模型

java语言

线程模型

在Java诞生之初，在Java中就引入了线程，最初称之为“绿色线程”，完全由JVM进行管理，这和操作系统用户线程是多对一的实现，但随着操作系统对线程支持越来越强大，java中的线程实现采用了一对一的实现，即一个java线程对应于一个操作系统用户线程，但是这个线程的堆栈大小是固定的，随着线程数量创建过多，可能导致内存溢出。在java19版本中引入了虚拟线程的概念，虚拟线程有一个动态的堆栈，可以增大和缩小，这和操作系统用户线程之间是一个多对多的关系，随着后面的发展，java中的线程模型会变得越来越强大。

优缺点

作为一对一的线程模型维护起来比较简单，但是由于每一个线程栈信息是固定的，不利于创建大量的线程，并且多线程操作时可能涉及频繁的系统调用，上下文切换代价高。

使用方式(以生产者消费者模型来说明)

  1.  public class ThreadTest {
  3.     public static final Object P = new Object();
  5.     static List<Integer> list = new ArrayList<>();
  7.     @Test
  8.     public void test() throws Exception {
  10.         Thread thread1 = new Thread(()-> {
  11.             while(true) {
  12.                 try {
  13.                     product();
  14.                 }catch (Exception e) {
  15.                     e.printStackTrace();
  16.                 }
  17.             }
  18.         });
  19.         Thread thread2 = new Thread(() -> {
  20.             while(true) {
  21.                 try {
  22.                     consume();
  23.                 }catch (Exception e) {
  24.                     e.printStackTrace();
  25.                 }
  26.             }
  27.         });
  28.         thread1.start();
  29.         thread2.start();
  31.         thread1.join();
  32.         thread2.join();
  33.     }
  35.     private static void product() throws Exception {
  36.         synchronized (P) {
  37.             if(list.size() == 1) {
  38.                 // 让出锁
  39.                 P.wait();
  40.             }
  41.             list.add(1);
  42.             System.out.println("produce");
  43.             P.notify();
  44.         }
  45.     }
  47.     private static void consume() throws Exception {
  48.         synchronized (P) {
  49.             if(list.size() == 0) {
  50.                 P.wait();
  51.             }
  52.             list.remove(list.size() - 1);
  53.             System.out.println("consume");
  54.             P.notify();
  55.         }
  56.     }
  57. }

go语言

go语言线程模型

在go语言中，线程模型就是比较强大了，包含了三个概念：内核线程（M）、goroutine(G)、G的上下文环境（P）。其中G表示基于协程创建的用户线程，M直接关联一个内核线程，P里面一般存放正在运行的goroutine的上下文环境（函数指针、堆栈地址和地址边界等）。

优缺点

go语言中的线程模型算是很强大了，引用了协程，线程栈大小可以动态调整，很好地避免了java中目前的线程模型缺点。

使用方式(以生产者消费者模型来说明)

  1. package main
  3. import (
  4. 	"fmt"
  5. )
  7. type ThreadTest struct {
  8. 	lock chan int
  9. }
  11. func (t *ThreadTest) produce() {
  12. 	for {
  13. 		t.lock <- 10
  14. 		fmt.Println("produce:", 10)
  15. 	}
  16. }
  18. func (t *ThreadTest) consume() {
  19. 	for {
  20. 		v := <-t.lock
  21. 		fmt.Println("consume:", v)
  22. 	}
  23. }
  25. func main() {
  26. 	maxLen := 10
  27. 	t := &ThreadTest{
  28. 		make(chan int, maxLen),
  29. 	}
  30. 	// 重点在这里，开启新的协程，配合通道，让go的多线程变成非常优雅
  31. 	go t.consume()
  32. 	go t.produce()
  33. 	select {}
  35. }
  36.

c++语言

c++语言线程模型

在c++11中增加了操作thread库，提供对线程操作的进一步封装，而这个库底层是使用了pthread库，这个库底层采用了1:1线程模型，跟java中的线程模型类似。

优缺点

作为一对一的线程模型维护起来比较简单，但是由于每一个线程栈信息是固定的，不利于创建大量的线程，并且多线程操作时可能涉及频繁的系统调用，上下文切换代价高。

使用方式(以生产者消费者模型来说明)

  1. #include 
  2. #include 
  3. #include 
  4. #include  
  6. static const int SIZE = 10;
  7. static const int ITEM_SIZE = 30;
  9. std::mutex mtx;
  11. std::condition_variable not_full;
  12. std::condition_variable not_empty;
  14. int items[SIZE];
  16. static std::size_t r_idx = 0;
  17. static std::size_t w_idx = 0;
  19. void produce(int i) {
  20.     std::unique_lock lck(mtx);
  21.     while((w_idx+ 1) % SIZE == r_idx) {
  22.         std::cout << "队列满了" << std::endl;
  23.         not_full.wait(lck);
  24.     }
  25.     items[w_idx] = i;
  26.     w_idx = (w_idx+ 1) % SIZE;
  27.     not_empty.notify_all();
  28.     lck.unlock();
  29. }
  31. int consume() {
  32.     int data;
  33.     std::unique_lock lck(mtx);
  34.     while(w_idx == r_idx) {
  35.         std::cout << "队列为空" << std::endl;
  36.         not_empty.wait(lck);
  37.     }
  38.     data = items[r_idx];
  39.     r_idx = (r_idx + 1) % SIZE;
  40.     not_full.notify_all();
  41.     lck.unlock();
  42.     return data;
  43. }
  45. void p_t() {
  46.     for(int i = 0; i < ITEM_SIZE; i++) {
  47.         produce(i);
  48.     }
  49. }
  51. void c_t() {
  52.     static int cnt = 0;
  53.     while(1) {
  54.         int item = consume();
  55.         std::cout << "消费第" << item << "个商品" << std::endl;
  56.         if(++cnt == ITEM_SIZE) {
  57.             break;
  58.         }
  59.     }
  60. }
  62. int main() {
  63.     std::thread producer(p_t);
  64.     std::thread consumer(c_t);
  65.     producer.join();
  66.     consumer.join();
  67. }

python语言

python线程模型

python中的线程使用了操作系统的原生线程，python虚拟机使用了一个全局互斥锁（GIL）来互斥线程对Python虚拟机的使用，当一个线程获取GIL的权限之后，其他的线程必须等待这个线程释放GIL锁，索引再多核CPU上，python多线程也会退化为单线程，无法利用多核的优势。

优缺点

python语言多线程由于GIL的存在，在计算密集型场景上，很难体现到优势，并且由于涉及线程切换的代码，反而可能性能还不如单线程好。

使用方式(以生产者消费者模型来说明)

  1. #! /usr/bin/python3
  3. import threading
  4. import random
  5. import time
  7. total = 100
  8. lock = threading.Lock()
  9. totalTime = 10
  10. gTime = 0
  12. class Consumer(threading.Thread):
  13.         def run(self):
  14.                 global total
  15.                 global gTime
  16.                 while True:
  17.                         cur = random.randint(10, 100)
  18.                         lock.acquire()
  19.                         if total >= cur:
  20.                                 total -= cur
  21.                                 print("{}使用了{}, 当前剩余{}".format(threading.current_thread(), cur, total))
  22.                         else:
  23.                             print("{}准备使用{}，当前剩余{}，不足，不能消费".format(threading.current_thread(), cur, total))
  24.                         if gTime == totalTime:
  25.                                lock.release()
  26.                                break
  27.                         lock.release()
  28.                         time.sleep(0.7)
  30. class Producer(threading.Thread):
  31.     def run(self):
  32.            global total
  33.            global gTime
  34.            while True:
  35.                   cur = random.randint(10, 100)
  36.                   lock.acquire()
  37.                   if gTime == totalTime:
  38.                          lock.release()
  39.                          break
  40.                   total += cur
  41.                   print("{}生产了{}, 剩余{}".format(threading.current_thread(), cur, total))
  42.                   gTime+= 1
  43.                   lock.release()
  44.                   time.sleep(0.5)
  45. if __name__ == '__main__':
  46.        t1 = Producer(name="生产者")
  47.        t1.start()
  48.        t2 = Consumer(name="消费者")
  49.        t2.start()

总结

在目前的线程模型中，有1:1、M:1、M:N多种线程模型，具体采用哪种线程模型也和硬件和操作系统的支持程度有关，像诞生比较早的语言，普通采用M:1、1:1线程模型，像c++、java。而新诞生不久的go语言，采用的是M:N线程模型，在多线程的支持上更加强大。

感觉了解一下线程模型还是很有必要的，如果不清楚语言层面上的线程在操作系统层面怎么映射使用，在使用过程中就会不清不楚，可能会踩一些坑，我们都知道在java中不同无限的创建线程，这会导致内存溢出，go语言中对多线程支持更加强大，很多事情不需要我们再去关注了，在语言底层已经帮助我们做了。

每种语言的底层细节太多了，如果想深入研究某一个技术，还是得花精力去研究。

作者：京东零售 姜昌伟

来源：京东云开发者社区

原文链接：https://www.cnblogs.com/Jcloud/p/17559171.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

C++热门文章

  • C/C++编程笔记：编写不会在C ++中编译的C程序，我教你呀！
  • 洛谷 P2085 最小函数值
  • 使用C++界面框架ImGUI开发一个简单程序
  • C++ Json解析CJsonObject的详细使用
  • C++编译错误杂记
  • 二分法（二）：采用二分法解决“最小化最大值问题”
  • C++实现json字符串与map的转换
  • C++借助curses库实现俄罗斯方块
  • 长乐培训Day5
  • 【OpenFOAM】——OpenFOAM入门算例学习

    • C++推荐文章

  • #8. 「模板」树链剖分
  • 预设型 DP
  • Standard Template Libary or C++ Standard Library
  • 一种优秀的虚拟机内存架构 - AQ
  • 如何让 MGR 不从 Primary 节点克隆数据？
  • TLScanary：Pwn中的利器
  • c++临时对象导致的生命周期问题
  • C++(Qt)-GIS开发-简易瓦片地图下载器
  • 逆向通达信 x 逆向微信 x 逆向Qt
  • C++面向对象

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号