应用系统定制开发C和Java没那么香了，Serverless时代Rust即将称王？

应用系统定制开发笔者在上周参加阿里云应用系统定制开发开发者大会时，应用系统定制开发特别注意到一个现象就应用系统定制开发是这个概念被反复提及，应用系统定制开发其受关注程度提升明显，应用系统定制开发笔者仔细看了一下，Serverless应用系统定制开发的核心理念就是函数式计算，应用系统定制开发开发者不需要再关注具体的模块，应用系统定制开发云上部署的粒度变成了程序函数，自动伸缩、应用系统定制开发扩容等工作完全由云服务负责，能够想象Serverless应用系统定制开发必将在未来引领时代潮流。

Serverless Computing，即”应用系统定制开发无服务器计算”，应用系统定制开发其实这一概念在刚刚提应用系统定制开发出的时候并没有获得太多的关注，直到2014年AWS Lambda应用系统定制开发这一里程碑式的产品出现。Serverless应用系统定制开发算是正式走进了云计算的舞台。2018年5月，Google在KubeCon+CloudNative 2018应用系统定制开发期间开源了gVisor应用系统定制开发容器沙箱运行时并分享了它的设计理念和原则。随后2018年的Google Next大会上Google推出了自己的 Google Serverless平台 —— gVisor。同年AWS又放了颗大炮仗-Firecracker，这是一款基于Rust语言编写的安全沙箱基础组件，用于函数计算服务Lambda和托管的容器服务。而值得注意的是Google也并没有死守自己一手缔造的平台，而是选择了Go与Rust的模式，据说Google在Rust方面也开始招兵买马，也要用Rust重写之前基于Go编写的Serverless平台。

笔者写本文的初衷，其实就是要回答为什么在这个高并发大行其道的时代，以性能著称的C语言和以安全高效闻名的Java都不香了呢？

高并发模式初探

在这个高并发时代最重要的设计模式无疑是生产者、消费者模式，比如著名的消息队列kafka其实就是一个生产者消费者模式的典型实现。其实生产者消费者问题，也就是有限缓冲问题，可以用以下场景进行简要描述，生产者生成一定量的产品放到库房，并不断重复此过程；与此同时，消费者也在缓冲区消耗这些数据，但由于库房大小有限，所以生产者和消费者之间步调协调，生产者不会在库房满的情况放入端口，消费者也不会在库房空时消耗数据。详见下图：

而如果在生产者与消费者之间完美协调并保持高效，这就是高并发要解决的本质问题。

  C语言的高并发案例

     笔者在前文曾经介绍过TDEngine的相关代码，其中Sheduler模块的相关调度算法就使用了生产、消费者模式进行消息传递功能的实现，也就是有多个生产者(producer)生成并不断向队列中传递消息，也有多个消费者（consumer）不断从队列中取消息。

后面我们也会说明类型功能在Go、Java等高级语言中类似的功能已经被封装好了，但是在C语言中你就必须要用好互斥体（ mutex）和信号量（semaphore）并协调他们之间的关系。由于C语言的实现是最复杂的，先来看结构体设计和他的注释：

  1. typedef struct {
  2.   char            label[16];//消息内容
  3.   sem_t           emptySem;//此信号量代表队列的可写状态
  4.   sem_t           fullSem;//此信号量代表队列的可读状态
  5.   pthread_mutex_t queueMutex;//此互斥体为保证消息不会被误修改，保证线程程安全
  6.   int             fullSlot;//队尾位置
  7.   int             emptySlot;//队头位置
  8.   int             queueSize;#队列长度
  9.   int             numOfThreads;//同时操作的线程数量
  10.   pthread_t *     qthread;//线程指针
  11.   SSchedMsg *     queue;//队列指针
  12. } SSchedQueue;
  13.  
  14.  
  15.

   再来看Shceduler初始化函数，这里需要特别说明的是，两个信号量的创建，其中emptySem是队列的可写状态，初始化时其值为queueSize，即初始时队列可写，可接受消息长度为队列长度，fullSem是队列的可读状态，初始化时其值为0，即初始时队列不可读。具体代码及我的注释如下：

  1. void *taosInitScheduler(int queueSize, int numOfThreads, char *label) {
  2.   pthread_attr_t attr;
  3.   SSchedQueue *  pSched = (SSchedQueue *)malloc(sizeof(SSchedQueue));
  4.  
  5.   memset(pSched, 0, sizeof(SSchedQueue));
  6.   pSched->queueSize = queueSize;
  7.   pSched->numOfThreads = numOfThreads;
  8.   strcpy(pSched->label, label);
  9.  
  10.   if (pthread_mutex_init(&pSched->queueMutex, NULL) < 0) {
  11.     pError("init %s:queueMutex failed, reason:%s", pSched->label, strerror(errno));
  12.     goto _error;
  13.   }
  14.    //emptySem是队列的可写状态，初始化时其值为queueSize，即初始时队列可写，可接受消息长度为队列长度。
  15.   if (sem_init(&pSched->emptySem, 0, (unsigned int)pSched->queueSize) != 0) {
  16.     pError("init %s:empty semaphore failed, reason:%s", pSched->label, strerror(errno));
  17.     goto _error;
  18.   }
  19.  //fullSem是队列的可读状态，初始化时其值为0，即初始时队列不可读
  20.   if (sem_init(&pSched->fullSem, 0, 0) != 0) {
  21.     pError("init %s:full semaphore failed, reason:%s", pSched->label, strerror(errno));
  22.     goto _error;
  23.   }
  24.  
  25.   if ((pSched->queue = (SSchedMsg *)malloc((size_t)pSched->queueSize * sizeof(SSchedMsg))) == NULL) {
  26.     pError("%s: no enough memory for queue, reason:%s", pSched->label, strerror(errno));
  27.     goto _error;
  28.   }
  29.  
  30.   memset(pSched->queue, 0, (size_t)pSched->queueSize * sizeof(SSchedMsg));
  31.   pSched->fullSlot = 0;//实始化时队列为空，故队头和队尾的位置都是0
  32.   pSched->emptySlot = 0;//实始化时队列为空，故队头和队尾的位置都是0
  33.  
  34.   pSched->qthread = malloc(sizeof(pthread_t) * (size_t)pSched->numOfThreads);
  35.  
  36.   pthread_attr_init(&attr);
  37.   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
  38.  
  39.   for (int i = 0; i < pSched->numOfThreads; ++i) {
  40.     if (pthread_create(pSched->qthread + i, &attr, taosProcessSchedQueue, (void *)pSched) != 0) {
  41.       pError("%s: failed to create rpc thread, reason:%s", pSched->label, strerror(errno));
  42.       goto _error;
  43.     }
  44.   }
  45.  
  46.   pTrace("%s scheduler is initialized, numOfThreads:%d", pSched->label, pSched->numOfThreads);
  47.  
  48.   return (void *)pSched;
  49.  
  50. _error:
  51.   taosCleanUpScheduler(pSched);
  52.   return NULL;
  53. }

再来看读消息的taosProcessSchedQueue函数这其实是消费者一方的实现，这个函数的主要逻辑是

1.使用无限循环，只要队列可读即sem_wait(&pSched->fullSem)不再阻塞就继续向下处理
2.在操作msg前，加入互斥体防止msg被误用。
3.读操作完毕后修改fullSlot的值，注意这为避免fullSlot溢出，需要对于queueSize取余。同时退出互斥体。
4.对emptySem进行post操作，即把emptySem的值加1，如emptySem原值为5，读取一个消息后，emptySem的值为6，即可写状态，且能接受的消息数量为6

具体代码及注释如下：

  1. void *taosProcessSchedQueue(void *param) {
  2.   SSchedMsg    msg;
  3.   SSchedQueue *pSched = (SSchedQueue *)param;
  4.  //注意这里是个无限循环，只要队列可读即sem_wait(&pSched->fullSem)不再阻塞就继续处理
  5.   while (1) {
  6.     if (sem_wait(&pSched->fullSem) != 0) {
  7.       pError("wait %s fullSem failed, errno:%d, reason:%s", pSched->label, errno, strerror(errno));
  8.       if (errno == EINTR) {
  9.         /* sem_wait is interrupted by interrupt, ignore and continue */
  10.         continue;
  11.       }
  12.     }
  13.      //加入互斥体防止msg被误用。
  14.     if (pthread_mutex_lock(&pSched->queueMutex) != 0)
  15.       pError("lock %s queueMutex failed, reason:%s", pSched->label, strerror(errno));
  16.  
  17.     msg = pSched->queue[pSched->fullSlot];
  18.     memset(pSched->queue + pSched->fullSlot, 0, sizeof(SSchedMsg));
  19.     //读取完毕修改fullSlot的值，注意这为避免fullSlot溢出，需要对于queueSize取余。
  20.     pSched->fullSlot = (pSched->fullSlot + 1) % pSched->queueSize;
  21.      //读取完毕修改退出互斥体
  22.     if (pthread_mutex_unlock(&pSched->queueMutex) != 0)
  23.       pError("unlock %s queueMutex failed, reason:%s\", pSched->label, strerror(errno));
  24.      //读取完毕对emptySem进行post操作，即把emptySem的值加1，如emptySem原值为5，读取一个消息后，emptySem的值为6，即可写状态，且能接受的消息数量为6
  25.     if (sem_post(&pSched->emptySem) != 0)
  26.       pError("post %s emptySem failed, reason:%s\", pSched->label, strerror(errno));
  27.  
  28.     if (msg.fp)
  29.       (*(msg.fp))(&msg);
  30.     else if (msg.tfp)
  31.       (*(msg.tfp))(msg.ahandle, msg.thandle);
  32.   }
  33. }

 最后写消息的taosScheduleTask函数也就是生产的实现，其基本逻辑是

1.写队列前先对emptySem进行减1操作，如emptySem原值为1，那么减1后为0，也就是队列已满，必须在读取消息后，即emptySem进行post操作后，队列才能进行可写状态。
 2.加入互斥体防止msg被误操作，写入完成后退出互斥体
3.写队列完成后对fullSem进行加1操作，如fullSem原值为0，那么加1后为1，也就是队列可读，咱们上面介绍的读取taosProcessSchedQueue中sem_wait(&pSched->fullSem)不再阻塞就继续向下。

  1. int taosScheduleTask(void *qhandle, SSchedMsg *pMsg) {
  2.   SSchedQueue *pSched = (SSchedQueue *)qhandle;
  3.   if (pSched == NULL) {
  4.     pError("sched is not ready, msg:%p is dropped", pMsg);
  5.     return 0;
  6.   }
  7.   //在写队列前先对emptySem进行减1操作，如emptySem原值为1，那么减1后为0，也就是队列已满，必须在读取消息后，即emptySem进行post操作后，队列才能进行可写状态。
  8.   if (sem_wait(&pSched->emptySem) != 0) pError("wait %s emptySem failed, reason:%s", pSched->label, strerror(errno));
  9. //加入互斥体防止msg被误操作
  10.   if (pthread_mutex_lock(&pSched->queueMutex) != 0)
  11.     pError("lock %s queueMutex failed, reason:%s", pSched->label, strerror(errno));
  12.  
  13.   pSched->queue[pSched->emptySlot] = *pMsg;
  14.   pSched->emptySlot = (pSched->emptySlot + 1) % pSched->queueSize;
  15.  
  16.   if (pthread_mutex_unlock(&pSched->queueMutex) != 0)
  17.     pError("unlock %s queueMutex failed, reason:%s", pSched->label, strerror(errno));
  18.   //在写队列前先对fullSem进行加1操作，如fullSem原值为0，那么加1后为1，也就是队列可读，咱们上面介绍的读取函数可以进行处理。
  19.   if (sem_post(&pSched->fullSem) != 0) pError("post %s fullSem failed, reason:%s", pSched->label, strerror(errno));
  20.  
  21.   return 0;
  22. }

Java的高并发实现

从并发模型来看，Go和Rust都有channel这个概念，也都是通过Channel来实现线（协）程间的同步，由于channel带有读写状态且保证数据顺序，而且channel的封装程度和效率明显可以做的更高，因此Go和Rust官方都会建议使用channel（通信）来共享内存，而不是使用共享内存来通信。

为了让帮助大家找到区别，我们先以Java为例来，看一下没有channel的高级语言Java，生产者消费者该如何实现，代码及注释如下：

  1. public class Storage {
  2.  
  3.     // 仓库最大存储量
  4.     private final int MAX_SIZE = 10;
  5.     // 仓库存储的载体
  6.     private LinkedList<Object> list = new LinkedList<Object>();
  7.     // 锁
  8.     private final Lock lock = new ReentrantLock();
  9.     // 仓库满的信号量
  10.     private final Condition full = lock.newCondition();
  11.     // 仓库空的信号量
  12.     private final Condition empty = lock.newCondition();
  13.  
  14.     public void produce()
  15.     {
  16.         // 获得锁
  17.         lock.lock();
  18.         while (list.size() + 1 > MAX_SIZE) {
  19.             System.out.println("【生产者" + Thread.currentThread().getName()
  20. 		             + "】仓库已满");
  21.             try {
  22.                 full.await();
  23.             } catch (InterruptedException e) {
  24.                 e.printStackTrace();
  25.             }
  26.         }
  27.         list.add(new Object());
  28.         System.out.println("【生产者" + Thread.currentThread().getName() 
  29. 				 + "】生产一个产品，现库存" + list.size());
  30.  
  31.         empty.signalAll();
  32.         lock.unlock();
  33.     }
  34.  
  35.     public void consume()
  36.     {
  37.         // 获得锁
  38.         lock.lock();
  39.         while (list.size() == 0) {
  40.             System.out.println("【消费者" + Thread.currentThread().getName()
  41. 		             + "】仓库为空");
  42.             try {
  43.                 empty.await();
  44.             } catch (InterruptedException e) {
  45.                 e.printStackTrace();
  46.             }
  47.         }
  48.         list.remove();
  49.         System.out.println("【消费者" + Thread.currentThread().getName()
  50. 		         + "】消费一个产品，现库存" + list.size());
  51.  
  52.         full.signalAll();
  53.         lock.unlock();
  54.     }
  55. }

 

在Java、C#这种面向对象，但是没有channel语言中，生产者、消费者模式至少要借助一个lock和两个信号量共同完成。其中锁的作用是保证同是时间，仓库中只有一个用户进行数据的修改，而还需要表示仓库满的信号量，一旦达到仓库满的情况则将此信号量置为阻塞状态，从而阻止其它生产者再向仓库运商品了，反之仓库空的信号量也是一样，一旦仓库空了，也要阻其它消费者再前来消费了。

Go的高并发实现

我们刚刚也介绍过了Go语言中官方推荐使用channel来实现协程间通信，所以不需要再添加lock和信号量就能实现模式了，以下代码中我们通过子goroutine完成了生产者的功能，在在另一个子goroutine中实现了消费者的功能，注意要阻塞主goroutine以确保子goroutine能够执行，从而轻而易举的就这完成了生产者消费者模式。下面我们就通过具体实践中来看一下生产者消费者模型的实现。

  1. package main
  2.  
  3. import (
  4. 	"fmt"
  5. 	"time"
  6. )
  7.  
  8. func Product(ch chan<- int) { //生产者
  9. 	for i := 0; i < 3; i++ {
  10. 		fmt.Println("Product  produceed", i)
  11. 		ch <- i //由于channel是goroutine安全的,所以此处没有必要必须加锁或者加lock操作.
  12. 	}
  13. }
  14. func Consumer(ch <-chan int) {
  15. 	for i := 0; i < 3; i++ {
  16. 		j := <-ch //由于channel是goroutine安全的,所以此处没有必要必须加锁或者加lock操作.
  17. 		fmt.Println("Consmuer consumed ", j)
  18. 	}
  19. }
  20. func main() {
  21. 	ch := make(chan int)
  22. 	go Product(ch)//注意生产者与消费者放在不同goroutine中
  23. 	go Consumer(ch)//注意生产者与消费者放在不同goroutine中
  24. 	time.Sleep(time.Second * 1)//防止主goroutine退出
  25. 	/*运行结果并不确定，可能为
  26. 		Product  produceed 0
  27. 	Product  produceed 1
  28. 	Consmuer consumed  0
  29. 	Consmuer consumed  1
  30. 	Product  produceed 2
  31. 	Consmuer consumed  2
  32. 	*/
  33.  
  34. }

可以看到和Java比起来使用GO来实现并发式的生产者消费者模式的确是更为清爽了。

Rust的高并发实现

不得不说Rust的难度实在太高了，虽然笔者之前在汇编、C、Java等方面的经验可以帮助我快速掌握Go语言。但是假期看了两天Rust真想大呼告辞，这尼玛也太劝退了。在Rust官方提供的功能中，其实并不包括多生产者、多消费者的channel，std:sync空间下只有一个多生产者单消费者（mpsc)的channel。其样例实现如下：

  1. use std::sync::mpsc;
  2. use std::thread;
  3. use std::time::Duration;
  4.  
  5. fn main() {
  6.     let (tx, rx) = mpsc::channel();
  7.     let tx1 = mpsc::Sender::clone(&tx);
  8.     let tx2 = mpsc::Sender::clone(&tx);
  9.  
  10.     thread::spawn(move || {
  11.         let vals = vec![
  12.             String::from("1"),
  13.             String::from("3"),
  14.             String::from("5"),
  15.             String::from("7"),
  16.         ];
  17.  
  18.         for val in vals {
  19.             tx1.send(val).unwrap();
  20.             thread::sleep(Duration::from_secs(1));
  21.         }
  22.     });
  23.  
  24.     thread::spawn(move || {
  25.         let vals = vec![
  26.             String::from("11"),
  27.             String::from("13"),
  28.             String::from("15"),
  29.             String::from("17"),
  30.         ];
  31.  
  32.         for val in vals {
  33.             tx.send(val).unwrap();
  34.             thread::sleep(Duration::from_secs(1));
  35.         }
  36.     });
  37.  
  38.     thread::spawn(move || {
  39.         let vals = vec![
  40.             String::from("21"),
  41.             String::from("23"),
  42.             String::from("25"),
  43.             String::from("27"),
  44.         ];
  45.  
  46.         for val in vals {
  47.             tx2.send(val).unwrap();
  48.             thread::sleep(Duration::from_secs(1));
  49.         }
  50.     });
  51.  
  52.     for rec in rx {
  53.         println!("Got: {}", rec);
  54.     }
  55. }

可以看到在Rust下实现生产者消费者是不难的，但是生产者可以clone多个，不过消费者却只能有一个，究其原因是因为Rust下没有GC也就是垃圾回收功能，而想保证安全Rust就必须要对于变更使用权限进行严格管理。在Rust下使用move关键字进行变更的所有权转移，但是按照Rust对于变更生产周期的管理规定，线程间权限转移的所有权接收者在同一时间只能有一个，这也是Rust官方只提供MPSC的原因，

  1. use std::thread;
  2.  
  3. fn main() {
  4.     let s = "hello";
  5.    
  6.     let handle = thread::spawn(move || {
  7.         println!("{}", s);
  8.     });
  9.  
  10.     handle.join().unwrap();
  11. }

当然Rust下有一个API比较贴心就是join，他可以所有子线程都执行结束再退出主线程，这比Go中要手工阻塞还是要有一定的提高。而如果你想用多生产者、多消费者的功能，就要入手crossbeam模块了，这个模块掌握起来难度也真的不低。

总结

通过上面的比较我们可以用一张表格来说明几种主流语言的情况对比：

语言安全性运行速度进程启动速度学习难度
C低极快极快困难
Java高一般一般一般
Go高较快较快一般
Rust高极快(基本比肩C）极快(基本比肩C）极困难

可以看到Rust以其高安全性、基本比肩C的运行及启动速度必将在Serverless的时代独占鳌头，Go基本也能紧随其后，而C语言程序中难以避免的野指针，Java相对较低的运行及启动速度，可能都不太适用于函数式运算的场景，Java在企业级开发的时代打败各种C#之类的对手，但是在云时代好像还真没有之前统治力那么强了，真可谓是打败你的往往不是你的对手，而是其它空间的降维打击。

网站建设定制开发 软件系统开发定制 定制软件开发 软件开发定制 定制app开发 app开发定制 app开发定制公司 电商商城定制开发 定制小程序开发 定制开发小程序 客户管理系统开发定制 定制网站 定制开发 crm开发定制 开发公司 小程序开发定制 定制软件 收款定制开发 企业网站定制开发 定制化开发 android系统定制开发 定制小程序开发费用 定制设计 专注app软件定制开发 软件开发定制定制 知名网站建设定制 软件定制开发供应商 应用系统定制开发 软件系统定制开发 企业管理系统定制开发 系统定制开发