「rust取代java」rust取代C++ 2022

今天给各位分享rust取代java的知识，其中也会对rust取代C++ 2022进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、rust可以代替javascript吗
• 2、rust性能到底有多好
• 3、哪种高级编程语言的执行速度最快？
• 4、Java和Rust在实现多线程编程时的异同
• 5、我为什么要选择Rust
• 6、未来比较有前景的8种编程语言，看看有没有你已经掌握的？

rust可以代替javascript吗

不会取代的。javascript是一种页面脚本，通过执行程序脚本片段，我们可以对页面及页面上的元素进行操作，实现特定的功能与效果。

而Rust是Mozilla开发的注重安全、性能和并发性的编程语言。

创建这个新语言的目的是为了解决一个顽疾：软件的演进速度大大低于硬件的演进，软件在语言级别上无法真正利用多核计算带来的性能提升。Rust是针对多核体系提出的语言，并且吸收一些其他动态语言的重要特性，比如不需要管理内存，比如不会出现Null指针等等。

rust将来有可能取代c或者c++，但是无法撼动javascript在业界的地位。

rust性能到底有多好

这个和c++大同小异。 因为把大量的运行时放到了编译时。 只不过编译器优化不够还达不到c++性能。

其实rust和c++的关系很想scala和java的关系。 rust和c++很多概念甚至库都是通用的，抽象化方式，比如泛性，多态，可变性，拷贝构造，移动构造，都是一样的。 你要是写过c++再来写rust，就会吐槽原来这个功能也有啊...

运行速度上rust c++ java都是大同小异，io处理上 java甚至比rust还要快。内存消耗rust和c++是一个级别的，都非常低。 另外很多人写rust喜欢用arc cellref这些只能指针， 其实是给这些变量增加了动态性会导致额外开销，所以这些特性用多了后，rust性能也不会太高：

哪种高级编程语言的执行速度最快？

回答时间2019年下半年

仅限高级语言

排名由前到后

性能 C Rust C++ Ada Java Pascal Chapel Lisp Ocaml Fortran Swift Haskell CSharp(C#) Go Dart F# Javascript Racket

时间 C Rust C++ Ada Java Chapel Go Pascal Ocaml C# Lisp Haskell Swift Fortran F# Javascript Dart Racket

内存占用 Pascal Go C Fortran C++ Ada Rust Lisp Haskell PHP Swift Python Ocmal C# Hack Racket

性能 对CPU资源消耗程度 越少越好

时间 运行同样代码任务所需时间 越短越好

内存占用 对内存的消耗 越少越好

C Rust C++ Ada 都是强类型的静态语言，性能非常接近，java可以说的带runtime的最快的语言。目前这四门顶级性能高级语言中最设计先进的是Rust，由于rust为了解决C系遗留安全问题，引入了ownership lifetime reference，因此最难入门的也是Rust。C C++ 入门较容易，但设计复杂的大型项目时C和C++将会变得困难，特别是C。建议学习路线 CC++Rust。

Java和Rust在实现多线程编程时的异同

Java的实现

打开Follower.java里的这个函数

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

处理并发有wait、notify和notiyall，有兴趣的朋友可以去这里了解一下：。Follower就是一个等待leader发送invitation，处理并返回结果的过程。

Leader.java

这么一段代码：

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

Rust的实现

Leader的结构为：

Follower的结构为：

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

下面简单介绍一下分别是做什么用的：

ArcT实现了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，通过引用计数的方法来保证对象只要还被其中任何一个线程引用就不会被释放掉，从而保证了前面说的：这个类型在多线程并发时没有导致内存不安全的可能性。

如果我们不定义为Arc就传到其他线程使用，编译器会报：

error: capture of moved value: `data`

data[i] += 1;

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

接下来我们看Mutex：

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

那我们又是怎么用Mutex的呢？就是用lock().unwrap()。lock()的作用是获取对象，如果当前有其他线程正在使用MutexT里面的T对象时，本线程就会阻塞，从而保证同时只有一个线程来访问对象，mutex也另外提供了try_lock()的方法，是不阻塞的，只要其他线程被占用，就返回err，通常Arc和Mutex都是一起使用的。

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

在我的Rust实现里，关键的语句是以下几个：

let leaders = (0..leader_cnt).map(|i|

Arc::new(Mutex::new(Leader::new(i,dance_types.len() as i32)))

).collect::Vec_();

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

同样Follower也是：

let followers = (0..follower_cnt).map(|i|

Arc::new(Mutex::new(Follower::new(i,dance_types.len() as i32,leader_cnt)))

).collect::Vec_();

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

这里定义了一堆的sender和receiver，其中把他们都作为leader和follower的成员变量存起来。大概意思就是每一个leader都通过sender列表可以发送invitation给所有follower，同时又有单个receiver来接受所有follower发给自己的处理结果inviresult。

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

这个是和Java实现多线程并发最大的不同之处！Java是通过给对象加锁，Rust是通过channel转移对象的所有权，在代码里，leader发送inv给folloer是下面这一句

match self.senders[*follower_id as usize].lock().unwrap().send(inv){，其中的lock().unwrap()是获得该leader对该follower的发送通道的所有权，send(inv)就是转移具体的发送对象invitation所有权了。

这个转移按照我的理解，应该是内存拷贝。就是在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的确需要开发者分部分精力到语法细节上。

编者注：冯总也有一些其它的实践体会，请参见CSDN对冯耀明的专访，请戳这里。也可以查看他的个人博客里的总结。

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

首先Rust里面的ownership和lifetime概念真的很酷，就因为这个概念实现无内存泄露，野指针和安全并发。

其次，Rust的语法不简单，也是有不少坑的，据说Rust的潜在用户应该是现在的C和C++程序员，他们可能会觉得比较习惯，说不定还 觉得更简单。由于ownership机制，一些在其他语言能够跑通的程序在Rust下就要调整实现了，它会改变你写程序的思维方式。据说一些写Rust超 过半年的程序员已经爱上它了！

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

初学者不熟悉ownership机制，会无数次编译失败。但一旦编译成功，那么程序只剩下逻辑错误了。同样，由于ownership机制，将来在项目里修改Rust代码将可能是痛苦的过程，因为原来编译通过的代码可能加入新功能就编译不过了，这是我的猜测。

Rust编译速度慢，不过据说最近每一个Rust新发布的版本编译速度都比之前的版本提高了30%。

Rust没有类，有的是结构体加方法，我喜欢这种简单的概念。

Rust没有类继承，只有接口，虽然接口可以提供默认的实现。这样一来，在大型项目里原来类继承来重用代码的效果是否就要用成员变量实例来完成呢？

Rust没有null，取而代之的是None和OptionT，也因此，结构体在初始化的时候必须初始化所有字段。

Rust有我一直很想要的错误值返回机制，而不必通过抛异常或者需要每每定义包含结果和错误体实现。

Rust用send和sync两个接口来处理多线程并发，其中ArcT和MutexT分别实现了这两个接口，简单易用。

Rust目前没有一个强大的IDE，支持断点调试，变量监控等。

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

进一步的思考：反转链表 - Java和Rust的不同实现

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

由于ownership的机制和不存在空指针的情况，很多在其他带GC的语言能够跑起来的程序在Rust下面就要换一种做法。最近试用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());

}

}

如果我们要反转链表，可以这么做：

public ListNode reverseList(ListNode head) {

if (head == null) {

return null;

}

ListNode pNext = head.next;

ListNode pPrevious = null;

while (head != null) {

pNext = head.next;

head.next = pPrevious;

pPrevious = head;

head = pNext;

}

return pPrevious;

}

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

struct ListNode{

id :i32,

next :OptionBoxListNode

}

反转链表：

fn reverseList2(head :mut OptionBoxListNode) - OptionBoxListNode {

match *head{

None = None,

Some(head) = {

let mut head = Some(head);

let mut pNext = head.unwrap().next;

let mut pPrevious:OptionBoxListNode = None;

while true {

match head {

None ={break;}

_ ={}

}

pNext = head.unwrap().next;

head.unwrap().next = pPrevious;

pPrevious = head;

head = pNext;

}

pPrevious

}

}

}

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

=》match *head{

ERROR：cannot move out of borrowed content

=》 pNext = head.unwrap().next;

ERROR：cuse of moved value: `head`

这些错误就是因为Rust的ownership机制，让我们无法像Java或者C++里保存临时变量，特别是在循环里。反复试过各种写法，都行不通。

最后，换成这么来做

链表定义：

use List::*;

enum List {

Cons1(i32, BoxList),

Nil,

}

// Methods can be attached to an enum

impl List {

#[inline]

fn new() - List {

Nil

}

#[inline]

fn prepend(self, elem: i32) - List {

Cons1(elem, Box::new(self))

}

fn len(self) - i32 {

match *self {

Cons1(_, ref tail) = 1 + tail.len(),

Nil = 0

}

}

fn stringify(self) - String {

match *self {

Cons1(head, ref tail) = {

format!("{}, {}", head, tail.stringify())

},

Nil = {

format!("Nil")

},

}

}

}

fn reverseList(list:List, acc:List ) - List{

match list{

Cons1(val,tail) = {

reverseList(*tail,acc.prepend(val))

}

Nil = acc

}

}

fn main() {

let mut head = List::new();

let mut i=0;

while i 10 {

i+=1;

head = head.prepend(i);

}

println!("{:30}",head.stringify());

let result = List::new();

let result = reverseList(head,result);

span style="white-space:pre" /spanprintln!("{:30}",result.stringify());

}

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

我为什么要选择Rust

你好，很高兴为你解答。

专访资深程序员庄晓立：我为什么要选择Rust？

Rust是由Mozilla开发的注重安全、性能和并发性的编程语言。这门语言自推出以来就得到了国内外程序员的大力推崇。Rust声称解决了传统C语言和C++语言几十年来饱受责难的内存安全问题，同时还保持了极高的运行效率、极深的底层控制、极广的应用范围。但在国内有关Rust的学习文档并不多见，不久前，笔者联系上了Rust1.0版本代码贡献者庄晓立（精彩博文：为什么我说Rust是靠谱的编程语言），请他分享Rust语言特性以及学习经验。

CSDN：你是从什么时候开始接触Rust语言的？是什么地方吸引了你？

庄晓立：我大概从2013年后半年开始深入接触Rust语言。它居然声称解决了传统C语言和C++语言几十年来饱受责难的内存安全问题，同时还保持了极高的运行效率、极深的底层控制、极广的应用范围。

其ownership机制令人眼前一亮，无虚拟机（VM）、无垃圾收集器（GC）、无运行时（Runtime）、无空指针/野指针/内存越界/缓冲区溢出/段错误、无数据竞争（Data Race）……所有这些，都深深地吸引了我——这个十多年以来深受C语言折磨的痛并快乐着的程序员。

CSDN：在你看来，Rust是怎样的一门语言？它适合开发什么类型的项目？为何你会说Rust不惧怕任何竞争对手，它既能取代C语言地位；又可挑战C++市场，还可向Java、Python分一杯羹？与这些语言相比，Rust有哪些优越的特性？

庄晓立：Rust是一门系统编程语言，特别适合开发对CPU和内存占用十分敏感的系统软件，例如虚拟机（VM）、容器（Container）、数据库/游戏/网络服务器、浏览器引擎、模拟器等，而这些向来主要都是C/C++的传统领地。

此外，Rust在系统底层开发领域，如裸金属（bare metal）、操作系统（OS）、内核（kernel）、内核模块（mod）等，也有强劲的实力，足以挑战此领域的传统老大C语言。Rust丰富的语言特性、先进的设计理念、便捷的项目管理，令它在上层应用开发中也能大展拳脚，至少在运行性能上比带VM和GC的语言要更胜一筹。无GC实现内存安全机制、无数据竞争的并发机制、无运行时开销的抽象机制，是Rust独特的优越特性。

其他语言很难同时实现这些目标，例如传统C/C++无法保证内存安全，Java/Python等无法消除运行时开销。但Rust毕竟还是很年轻的项目，它释放影响力需要时间，被世人广泛接受需要时间；它的潜力能否爆发出来，需要时间去检验。我们只需耐心等待。

CSDN：Rust在国内有没有具体的实际使用案例？

庄晓立：因为Rust1.0正式版刚刚发布不足一月，在国内影响力还不大，我们不能苛求它在国内有实际应用案例。但是在国外，一两年前就已经有OpenDNS和Skylight把Rust应用在生产环境。还有浏览器引擎Servo、Rust编译器和标准库、项目管理器Cargo等“两个半大型应用案例”。这些足够说明Rust语言的成熟和实用。

CSDN：你参与了Rust1.0版本代码贡献，目前该版本正式版已经发布，对此你感觉如何？这门语言是否已经达到比较成熟的阶段？

庄晓立：我积极参与了Rust语言开源项目，多次贡献源代码，曾连续三次出现在Rust官方博客公布的Rust 1.0 alpha、Rust 1.0 beta和Rust 1.0正式版的贡献者名单中。在Rust 1.0正式版出台的过程中及此前的很长一段时间，开发者付出了极大的努力，确保Rust 1.0正式版在Semver 2.0规范下，务必保持向后兼容性，除非遇到重大Bug不得不修复。

我认为，在1.0正式发布之后，Rust就已经进入了比较成熟的阶段。而且，Rust还在快速迭代发展过程中，1.0发布6周后将发布1.1，再6周后将发布1.2，必然会一步一个台阶，越来越成熟稳定。

CSDN：除了功能优先级以外，在你看来，Rust正在朝什么方向发展？未来的Rust可以期待什么样的特性？

庄晓立：Rust一定会沿着“确保内存安全、无运行开销、高效实用”的既定方向持续发展。在短期内值得期待的语言特性有：动态Drop、偏特化、继承、改进borrow checker、改进宏和语法扩展。短期内值得期待的其他特性有：增强文件系统API、提供内存申请释放API、更好地支持Windows和ARM、更快的编译速度、更方便的二进制分发机制（MUSL）、更实用的工具等等。

CSDN：据我了解，你之前也比较推崇Go语言，为何想到放弃Go转向Rust？

庄晓立：推崇Go语言还谈不上，不过我曾经尝试努力接受Go语言，2011底年开始我曾经花费将近半年时间深度关注Go开发进程，提了很多具体的改进意见和建议，也曾经多次尝试贡献源代码。后来考虑到Go语言的设计理念跟我偏差太大，其社区也不太友好，慢慢地疏远了它。我曾经写过一篇博客《我为什么放弃Go语言》，谈到了很多具体的原因。

CSDN：国内，参与Rust代码贡献的开发者多吗？有核心的人员吗？有哪些社区在维护Rust？

庄晓立：国内参与Rust代码贡献的开发者并不多，但也不少，官方的贡献者名单中也偶见几个貌似国人的名字。Rust的核心开发人员基本上都是Mozilla公司的员工，他们专职负责开发维护Rust语言和相关的项目，Rust社区也主要是他们参与组织和管理的。社区人员讨论主要集中在GitHub项目主页RFC/PR/Issue官方、Discuss论坛/IRC、Reddit、HN、StackOverflow等。

未来比较有前景的8种编程语言，看看有没有你已经掌握的？

目前，软件开发人员正在使用大量不同的编程语言，大多数工作需要熟悉很多技能，如Java、Java、PHP和C#。然而，随着软件需求的发展，新的和尚未被普遍接受的编程语言越来越突出，为程序员提供了针对某些工作的正确工具。

预测哪些语言最终会上升到编程语言排行榜的顶部是困难的，很多语言的受欢迎指数都呈上升趋势，以下是八种目前还没有大火的编程语言竞争力分析，看起来未来几年将在在企业中发挥巨大作用。(排名按照开源社区受欢迎程度，swift最受欢迎）

在2014年的苹果WWDC大会上首次亮相，旨在替代OSX和iOS开发的Objective-C语言。苹果于2015年12月，根据Apache许可证开源了该语言，这意味着所有源代码都可以编辑，程序可以在不归属于苹果的情况下运行。

RedMonk分析师Stephen O'Grady表示，Swift与Ruby和Python这些更现代的语言相似，自发布以来一直享受着高速增长。苹果公司表示： Swift采用安全的编程模式，并添加了现代功能，使编程更容易、更灵活、更有趣。

Github上Star：39.8K

这种开源语言被视为比较成熟的语言(如Java和C)更快速、更易于使用。它已被许多企业使用：BBC、SoundCloud，Facebook以及英国政府获奖的GOV.UK网站。

Type在年初开始普及，上半年保持着强劲的增长势头。这反映在其技术出版商RedMonk的排名中，在第一季度Github的排名中位列17位，其中Erlang和Rust并列。

被描述为“Java的超集”，Type最大的优点就是程序员可以利用Angular，这是一个用于创建以Type编写Web应用程序的框架。

Github上Star：24.6K

由Mozilla创建，Rust 1.0于2014年发布，已经开发了多年。

与C和C ++在某些方面类似，Mozilla将其描述为一种专注于性能、并行化和内存安全的新型编程语言。通过从零开始构建语言并结合现代编程语言设计的元素，Rust的创建者避免了传统语言必须处理大量”baggage“(向后兼容性要求)。经过一段时间的发展，该语言正在引起程序员的兴趣。

Github上Star：22.9K

快速编译并与Java一起运行，Kotlin是一种静态类型的编程语言，可在Java虚拟机上运行，可编译为Java源代码。

由俄罗斯软件开发公司JetBrains创建，Kotlin正在Pinterest，Evernote，Uber和Coursera上使用。

Github上Star：16.6k

Clojure于2009年推出，是Lisp编程语言的一种方言。它是一种强调函数式编程的通用语言。它将代码视为数据，并具有宏系统，如其他“Lisps”。

它被成功应用到沃尔玛、Puppet实验室和各大软件公司。

Github上Star：6.5k

Haskell将自己称为“高级纯函数式编程语言”，1990年发布了第一个版本。它具有类型推理系统，主要在学术界内使用，但有一些行业应用案例，例如ATT，BAE Systems，Facebook甚至Google的项目。

2016年，开始编制2020版本。

Github上Star：681

R提供用于统计计算的开源软件环境。

首先出现在1993年，R在数据驱动的职业之中，例如数据挖掘、统计学家甚至学者，受到了越来越多的欢迎。它提供了一个简单有效的方式来分析数据，尽管它不能与像Hadoop这样的大型架构相竞争。

普通程序员目前对R语言的接受程度一般，随着大数据以及人工智能的发展，R语言未来的发展前景还是很不错的。

Github上Star：240

关于rust取代java和rust取代C++ 2022的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。