分享人Info：

更多讲师观点请看CSDN独家专访：

《用Rust实现一个典型的生产者和消费者的题目》

相关的代码如下：

Java的实现

这里的Follower.this.invitations就是我们的消息队列，定义是：private linkedList<Invitation> invitations;linkedList不是线性安全的集合，需要我们加同步。具体的同步方法就是函数里写的，通过Java常见的用wait，notify和notifyall给对象加锁。

Leader.java

里面就是Leader发送邀请inv，并等待follower返回结果的大概逻辑，通过对消息体加锁，是Java传统的实现多线程并发的方式。还有消费者的消息队列也会加锁，在Java里，有个对象叫linkedBlockingQueue，是不用加锁就可以put和take的，但在例子里，我们选用了更简单的linkedList，也是为了表现一下加锁的逻辑。

Leader的结构为：

对于其他语言转过来的同学，这里的Vec，i32，bool都很好理解，不过里面出现的Arc和Mutex，Sender，Receiver就是新东西了，上面这4个都是Rust标准库的东西，也是这次分享要介绍的重点对象，是这4个东西共同实现了消息的生产，传递和消费。

Arc<T>实现了sync接口。Sync接口是做什么呢？权威资料是这么说的：当一个类型T实现了Sync，它向编译器表明这个类型在多线程并发时没有导致内存不安全的可能性。

在这个例子里，我们关注这几句：

• let data = Arc::new(Mutex::new(vec![1u32, 2, 3]));
• let data = data.clone;
  
• let mut data = data.lock.unwrap;

简单的说Arc::new表明了这是通过clone方法来使用的，每clone，都会给该对象原子计数+1，通过引用计数的方法来保证对象只要还被其中任何一个线程引用就不会被释放掉，从而保证了前面说的：这个类型在多线程并发时没有导致内存不安全的可能性。

我们可以记住clone就是Arc的用法。

Mutex实现了send接口。同样，在权威资料里是这么描述的：这个类型的所有权可以在线程间安全的转移

回到我最原始的题目，Mutex和Arc实现了对象本身的线程共享，但是在线程间如何传递这个对象呢？就是靠channel，channel通常是这么定义的let (tx, rx) = mpsc::channel;它会返回两个对象tx和rx，就是之前我提到的sender和receiver。

这一句是new一堆leader出来，Arc和Mutex表明leader是可以多线程共享和访问的。

接下来这几句就有点不好理解了。

同样follower也是这么做。这样在之后每一个follower和leader作为一个线程跑起来之后，都能在相互之间建立了一条通信的通道。

这个转移按照我的理解，应该是内存拷贝。就是在follower接收的时候，let inv = match self.receiver.recv { ，原来leader里面的inv在send之后已经是不可访问了，如果你之后再次访问了inv，会报use of moved value错误，而follower里面的inv则是在follower的栈里新生成的对象，所以，在Java里面我只定义了invitation对象，但是在Rust里面，我要再定义一个InviResult，因为我即使在follower线程里面填了result字段，leader线程也不能继续访问inv了。所以需要依靠follower再次发送一个invresult给leader，所以整个Rust程序大概就是这么一个思路。

之前我测试比较Java和Rust实现的性能时，由于没有把调试信息去掉，导致Java比Rust慢很多，特别是那些调试信息都是调用String.format，这是比几个string相加慢上10倍的方法，两者都去掉调试信息后，leader和follower都会2000的时候，在我低端外星人笔记本里，性能差别大概是2倍吧，没我想象中大，Rust的程序整个写下来比较费力，一方面是对ownership机制不熟，思维没有转变过来，另一方面Rust的确需要开发者分部分精力到语法细节上。

下面摘录采访中关于Rust的内容过来：

• 首先Rust里面的ownership和lifetime概念真的很酷，就因为这个概念实现无内存泄露，野指针和安全并发。
• 其次，Rust的语法不简单，也是有不少坑的，据说Rust的潜在用户应该是现在的C和C++程序员，他们可能会觉得比较习惯，说不定还 觉得更简单。由于ownership机制，一些在其他语言能够跑通的程序在Rust下就要调整实现了，它会改变你写程序的思维方式。据说一些写Rust超 过半年的程序员已经爱上它了！

我对Rust感受较深的是下面几点：

1. 初学者不熟悉ownership机制，会无数次编译失败。但一旦编译成功，那么程序只剩下逻辑错误了。同样，由于ownership机制，将来在项目里修改Rust代码将可能是痛苦的过程，因为原来编译通过的代码可能加入新功能就编译不过了，这是我的猜测。
2. Rust编译速度慢，不过据说最近每一个Rust新发布的版本编译速度都比之前的版本提高了30%。
3. Rust没有类，有的是结构体加方法，我喜欢这种简单的概念。
4. Rust没有类继承，只有接口，虽然接口可以提供默认的实现。这样一来，在大型项目里原来类继承来重用代码的效果是否就要用成员变量实例来完成呢？
5. Rust没有null，取而代之的是None和Option<T>，也因此，结构体在初始化的时候必须初始化所有字段。
6. Rust有我一直很想要的错误值返回机制，而不必通过抛异常或者需要每每定义包含结果和错误体实现。
7. Rust用send和sync两个接口来处理多线程并发，其中Arc<T>和Mutex<T>分别实现了这两个接口，简单易用。
8. Rust目前没有一个强大的IDE，支持断点调试，变量监控等。

它跟现在动态语言是两个截然不同的方向，它适合一些资深的程序员，我倒是觉得有必要有这么一本书，叫《从C++到Rust，你需要改善的20个编程 习惯》，能从实践上告诉开发者Rust里我们应该遵从什么样的编程习惯。Rust未来是否像C那样流行开来成为新一代的主流语言没有人能够知道，但它绝对 是值得你去了解和关注的语言。

Rust的list应该怎么定义，譬如反转列表又是怎么做呢？

在Java中，考虑最基本的链表定义

class ListNode {          int val;          ListNode next;            ListNode(int x) {              val = x;          }            @Override          public String toString {              StringBuilder sb = new StringBuilder;              sb.append("[");              sb.append(val);              ListNode pNext = this.next;              while (pNext != null) {                  sb.append(",");                  sb.append(pNext.val);                  pNext = pNext.next;              }              sb.append("]");              return String.format("%s", sb.toString);          }      }  

那如果我们按照一般思维，在Rust里对应的实现就是这样子的：

struct ListNode{      id :i32,      next :Option<Box<ListNode>>  }  

然后编译，报了以下错误：

ERROR：cannot move out of borrowed content

ERROR：cuse of moved value: `head`

最后，换成这么来做

从结果可以看到，链表已经实现反转了。所以在Rust下面，很多做法都要换一下。有人说这就是Rust函数式编程的思维。我但愿这种递归式的做法不会有溢出。

后续 CSDN Rust 学习交流群会邀请更多的大牛来进行分享，如果你想实时听课和提问，请加群主微信 qshuguang2008 或扫描下方二维码被邀请进群，备注：实名+公司名+Rust。