Rustは、Mozilla Corporationが開発した新しいプログラミング言語です。 開発者の主な目標は、並列コンピューティング用の安全で実用的な言語を作成することです。 この言語の最初のバージョンは、2006年にGraidon Choirによって作成され、2009年にMozillaが開発に参加しました。 それ以来、もともとOCamlで記述されていたコンパイラ自体も変更されました。LLVMをバックエンドとして使用して、Rustで正常に書き換えられました。



Rustで開発されている主な製品は、Mozillaでも開発されている新しいServo Webエンジンです。 2013年、Samsung Electronics CorporationはRustとServoの開発に参加し、その積極的な参加により、ServoエンジンコードがARMアーキテクチャに移植されました。 IT業界のこのような真剣なプレーヤーによるこの言語のサポートは喜ばずにはいられず、その積極的な開発と改善に希望を与えています。



Rust言語は、システムおよびネットワーク開発者、CおよびC ++でパフォーマンスが重要な職場で多くのコードを記述する必要のある開発者に好まれます。

1. Rustは安全なアプリケーションの開発に重点を置いています。 これには、メモリを使用した安全な作業が含まれます。nullポインターが存在しないこと、初期化されていない変数および初期化されていない変数の使用を制御すること。 共有状態を複数のタスクと共有することは不可能です。 ポインタの寿命の静的分析。
2. Rustは、並列アプリケーションの開発に重点を置いています。 ライト（グリーン）フロー、送信されるデータをコピーしない非同期メッセージング、スタック、ローカルタスクヒープ、またはタスク間で共有されるヒープ内のオブジェクトの場所を選択する機能のサポートを実装します。
3. Rustは、速度とメモリ効率の高いアプリケーションの開発に重点を置いています。 LLVMをバックエンドとして使用すると、アプリケーションをネイティブコードにコンパイルでき、Cコードとやり取りするためのシンプルなインターフェイスにより、既存の高性能ライブラリを簡単に使用できます。
4. Rustは、クロスプラットフォームアプリケーションの開発に重点を置いています。 コンパイラはWindows、Linux、およびMac OS Xプラットフォームで公式にサポートされており、FreeBSDなどの他の* NIXプラットフォームにもポートがあります。 いくつかのプロセッサアーキテクチャもサポートされています：i386、x64、およびARM。
5. Rustを使用すると、オブジェクト指向、機能、アクターベース、命令型などのさまざまなスタイルで記述できます。
6. Rustは、GDB、Valgrind、Instrumentsなどの既存のデバッグツールをサポートしています。

対象読者

最初に、変数宣言で始まり、メモリモデルの機能と機能で終わる非常に基本的なことから言語を調べる入門記事を書くことを計画しました。 一方で、そのようなアプローチは、可能な限り多くのターゲットオーディエンスにリーチすることを可能にします;一方、同様のコンテンツを含む記事は、C ++やJavaなどの言語での作業経験のある人にとっては面白くなく、メインの詳細な分析を許可しませんRustの機能、つまりまさにそれが魅力的です。



したがって、変数、ループ、関数、クロージャー、およびコードから明らかなその他のすべての作成などの基本的なことを詳細に説明しないことにしました。 Rustの主な機能を分析する過程で、完全には明らかではない機能の大部分が必要に応じて説明されます。 その結果、この記事では、この言語の3つの主要機能のうちの2つ、つまりメモリの安全な操作と並列アプリケーションの作成について説明します。 残念ながら、この記事の執筆時点では、ネットワークサブシステムは活発に開発されていたため、この記事での作業の説明はまったく無意味でした。

用語

概して、これはロシア語のRustに関する2つまたは3つの利用可能な記事の1つであるため、確立されたロシア語の用語はなく、他のプログラミング言語ですでによく知られている最も適切な同等物を採用する必要があります。 英語のドキュメントや記事をさらに読みやすくするために、ロシア語の用語が初めて登場するときは、英語での同等物が括弧内に示されています。



ほとんどの問題は、ボックスとポインターという用語が原因で発生しました。 BoxとPointerのプロパティは、C ++のスマートポインターを最もよく連想させるので、「ポインター」という用語を使用することにしました。 したがって、所有ボックスは一意のポインターに、借用ポインターは一時ポインターに変わりました。

メモリを操作する

メモリでの作業の原則は、この言語をメモリへのフルアクセスを持つ言語（C ++など）とGCからメモリを完全に制御する言語（Javaなど）の両方から区別するRustの主要な機能の最初の機能です。 実際、一方で、Rustは開発者にデータの配置場所を制御する機能を提供し、ポインターのタイプによる分離を導入し、コンパイル段階での使用を制御します。 一方、言語の最終バージョンでは本格的なGCに置き換えられるリンクカウントメカニズムにより、自動リソース管理が提供されます。



Rustには、さまざまなタイプのメモリにあるオブジェクトをアドレス指定し、さまざまなルールに従うポインターがいくつかあります。

• 共有ポインター（管理ボックス）。 タスクのローカルヒープにあるデータを指します。 複数の共有ポインターが同じオブジェクトをアドレス指定できます。
• 一意のポインター（所有ボックス）。 すべてのタスクに共通の、交換ヒープにあるデータを指します。 一度に1つのオブジェクトしかアドレス指定できません（「ARCモジュール」セクションのルールの例外を参照）。
• 一時ポインター（借用ポインター）。 スタック、ローカルヒープまたは交換ヒープなど、あらゆるタイプのオブジェクトを指すことができるユニバーサルポインター。 これらは主に、オブジェクトの配置のタイプが重要でない場合に関数内のデータを処理するユニバーサルコードを記述するために使用されます。
• 少し横にあるのは、スタックに置かれたオブジェクトです。 それらのアドレス指定には、区別できるタイプのポインターはありません。

概略的に、Rustメモリモデルは次のように表すことができます。

スタック使用量

let x = Point {x: 1f, y: 1f}; // (1) let y = x; // (2)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

したがって、コード（1）は、Point型のオブジェクトを、それが呼び出されるタスクのスタックに配置します。 そのようなオブジェクト（2）をコピーすると、オブジェクトxへのポインターではなく、Pointタイプの構造全体がコピーされます。

情報：変数

上記の例からわかるように、変数を作成するためにRustでletキーワードが使用されます。 デフォルトでは、すべての変数は定数であり、mutキーワードを追加して可変変数を作成する必要があります。 したがって、Point型の可変変数を作成すると、次のようになります。let mut x = Point {x：1f、y：1f};。



変数を操作するとき、定数であることが判明するのはデータであり、コンパイラが「トリック」によってそれらを変更しようとする試みを注意深く監視することを覚えておくことは非常に重要です。

 let x = Point {x:1, y:2}; let y = Point {x:2, y:3}; let mut px = &x; // (1) let py = &y; px.x = 42; // (2) px = py; // (3)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

そのため、（1）定数データを指す可変変数を作成することはかなり可能ですが、（2）データ自体を変更しようとすると、コンパイル段階でエラーが発生します。 ただし、定数Pointオブジェクトのアドレスを格納し、以前に作成された変数の値を変更することは有効です（3）。

 error: assigning to immutable field px.x = 42; ^~~~~
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

共有ポインター

共有ポインターは、ローカルタスクヒープにあるオブジェクトへのポインターとして使用されます。 各タスクには独自のローカルヒープがあり、タスク内にあるオブジェクトへのポインターを境界外に渡すことはできません。 共有ポインターを作成するには、単項演算子@を使用します

 let x = @Point {x: 1f, y: 1f};
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

スタックオブジェクトとは異なり、コピー時には、データではなくポインターのみがコピーされます。 このプロパティから、このタイプのポインターの名前は、C ++言語のshared_ptrに非常に似ているため、このタイプのポインターの名前になっています。

 let y = x; //  x  y     //     Point
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

また、独自の型へのポインタを含む構造を作成することは不可能であるという事実に注意する必要があります（典型的な例は、単純に接続されたリストです）。 コンパイラがこのような構造を許可するには、Option（1）型でポインタをラップする必要があります。

 struct LinkedList<T> { data: T, nextNode: Option<@LinkedList<T>> // (1) }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

一意のポインター

共有ポインターのような一意のポインターは、ヒープ上のオブジェクトへのポインターであり、その類似点はそこにあります。 一意のポインターによってアドレス指定されたデータは、すべてのタスクに共通の交換ヒープにあります。 一意のポインターを作成するには、単項演算子〜を使用します

 let p = ~Point {x: 1f, y: 1f};
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

一意のポインタは所有権のセマンティクスを実装するため、オブジェクトは1つの一意のポインタのみをアドレス指定できます。 C ++開発者は、一意のRustポインターとSTLのunique_ptrクラスの類似点を見つける可能性があります。

 let new_p = p; // (1) let val_x = px; // (2)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ポインターpのポインターnew_pに（1）を割り当てると、new_pは以前に作成されたPoint型のオブジェクトを指し始め、ポインターpは初期化されません。 初期化解除された変数（2）を操作しようとする場合、コンパイラーは移動値エラーの使用を生成し、その後の元の初期化解除でポインターを割り当てる代わりに変数のコピーを作成することを提案します。

 let p = ~Point {x: 1f, y: 1f}; let new_p = p.clone(); // (1)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

copy（1）の明示的な作成のおかげで、new_pは以前に作成されたPoint型のオブジェクトのコピーを指し、ポインターpは変わりません。 cloneメソッドをPoint構造に適用するには、＃[deriving（Clone）]属性を使用して構造を宣言する必要があります。

 #[deriving(Clone)] struct Point {x: float, y: float}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

一時的なポインター

一時的なポインター-可能なメモリの種類（スタック、ローカルまたはヒープ交換、およびデータ構造の内部メンバー）にあるオブジェクトを指すポインター。 物理レベルでは、一時ポインターは典型的なCポインターであり、その結果、ガベージコレクターによって監視されず、追加のオーバーヘッドが発生しません。 同時に、Cポインターとの主な違いは、安全な使用の可能性を保証するためにコンパイル段階で実行される追加のチェックです。 一時的なポインターを作成するには、単項演算子＆を使用します

 let on_the_stack = &Point {x: 3.0, y: 4.0}; // (1)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

タイプPointのオブジェクトがスタック上に作成され（1）、一時ポインターがon_the_stackに格納されました。 このコードは次のようなものです。

 let on_the_stack = Point {x: 3.0, y: 4.0}; let on_the_stack_pointer = &on_the_stack;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

スタック型以外の型は、アドレスを取る演算子を使用することなく、一時的なポインターに自動的に変換されます。これにより、ポインターの型が重要でない場合に関数（1）を簡単に記述できます。

 let on_the_stack : Point = Point {x: 3.0, y: 4.0}; let managed_box : @Point = @Point {x: 5.0, y: 1.0}; let owned_box : ~Point = ~Point {x: 7.0, y: 9.0}; fn compute_distance(p1: &Point, p2: &Point) -> float { // (1) let x_d = p1.x - p2.x; let y_d = p1.y - p2.y; sqrt(x_d * x_d + y_d * y_d) } compute_distance(&on_the_stack, managed_box); compute_distance(managed_box, owned_box);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

次に、データ構造の内部要素への一時的なポインターを取得する方法の簡単な図を示します。

 let y = &point.y;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

タイムポインタの寿命を監視することは、かなりボリュームがあり、確立されたトピックではありません。 必要に応じて、記事「Rust Borrowed Pointers Tutorial and Lifetime Notation」で詳細を読むことができます。

ポインターの逆参照

ポインターを使用してアドレス指定された値にアクセスするには、ポインターの参照解除操作を実行する必要があります。 構造化オブジェクトのフィールドにアクセスすると、参照解除が自動的に実行されます。

 let managed = @10; let owned = ~20; let borrowed = &30; let sum = *managed + *owned + *borrowed;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ポインター間の変換

Rustでの作業を開始した直後に、「一意のポインターを使用してアドレス指定されたオブジェクトを共有オブジェクトに、またはその逆に変換する方法は？」という疑問が生じます。この質問に対する答えは短く、最初はやや落胆します。 それについてよく考えてみると、オブジェクトは異なるヒープにあり、異なるルールに従うため、そのような変換の手段は存在せず、手段もあり得ないことが明らかになります。オブジェクトは依存関係グラフを持つことができ、これも自動的に追跡するのが困難です。 そのため、ポインタ間で変換する必要がある場合（ヒープ間でオブジェクトを移動するだけの場合）、シリアル化を使用できるオブジェクトのコピーを作成する必要があります。

タスク

Rustの2番目の重要な機能は、並列アプリケーションの作成です。 同時実行アプリケーションを作成するという点では、Rustはアクターモデルと、ErlangとLimboとの間のメッセージングでのチャネルを備えたErlangに似ています。 この場合、開発者には、メッセージを送信するときにメモリをコピーするか、単にオブジェクトの所有権を譲渡するかを選択する機会が与えられます。 また、複数のタスクが同じオブジェクトと連携して機能する場合、1人のライターが複数のリーダーのアクセスを簡単に整理できます。 作成されたタスクについては、最適なスケジューラを選択するか、独自のスケジューラを作成する機会があります。

詳細については、do-syntax

タスクの操作の説明に進む前に、Rustが高階関数の操作を簡略化するために使用するdo-syntaxを理解することをお勧めします。 例として、各関数を使用して、配列の各要素へのポインター（1）をop関数に渡すことができます。

 fn each(v: &[int], op: &fn(v: &int)) { let mut n = 0; while n < v.len() { op(&v[n]); // (1) n += 1; } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

do-syntax（1）を使用して各関数を使用すると、配列の各要素を表示できます。値がラムダに渡されるのではなく、データにアクセスするために逆参照する必要があるポインター（2）を忘れないでください：

 do each([1, 2, 3]) |n| { // (1) io::println(n.to_str()); // (2) }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

do構文は構文糖であるため、以下の表記はdo構文を使用した表記と同等です。

 each([1, 2, 3], |n| { io::println(n.to_str()); });
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

タスクを実行する

Rustでのタスクの作成と実行は非常に簡単です。 タスクの操作に関連するコードはstd :: taskモジュールに集中しており、タスクを作成して開始する最も簡単な方法は、このモジュールからspawn関数を呼び出すことです。

 use std::task; fn print_message() { println("Message form task 1"); } fn main() { spawn(print_message); // (1) spawn( || println("Message form task 2") ); // (2) do spawn { // (3) println("Message form task 3"); } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

spawn関数は、クロージャーを引数として受け取り、それをタスクとして起動します（Rustのタスクは緑のスレッドの上に実装されることを忘れないでください）。 コードが実行される現在のタスクを取得するには、タスクモジュールからget_task（）メソッドを使用できます。 クロージャはタスクのフレームワーク内で実行されるため、実行するタスクを開始する3つの方法を想定することは難しくありません。構文（3）。

タスク間の相互作用

Rustメモリモデルは、一般的な場合、異なるタスク（共有メモリモデル）から同じメモリへの共同アクセスを許可せず、代わりにタスク間のメッセージ交換（メールボックスモデル）を提供します。 同時に、いくつかのタスクでは、読み取り専用モードとマルチリーダーモードで共有メモリを操作できます。 タスク間の相互作用を整理するために、Rustは以下のメソッドを提供します

• std :: commモジュールの低レベルチャネルとポート。
• チャネルおよびポートを介した高レベルの抽象化extra :: comm;
• 余分な::フラットパイプからバイナリデータを送信するためのチャネル。

低レベルのメッセージング

現時点でタスク間で最も広く使用されている方法は、std :: commモジュールです。 std :: commのコードは、十分にデバッグされ、十分に文書化されており、かなり使いやすいです。 std :: commメッセージングエンジンの基礎はスレッドであり、これはチャネルとポートを介して操作されます。 ストリームは、ポートを使用してメッセージを送信し、チャネルを使用して送信情報を受信する単方向通信メカニズムです。 ストリームを使用する最も簡単な例は次のとおりです。

 let (chan, port) = stream(); // (1) port.send("data"); // (2) // port.send(1); // (3) println(chan.recv()); // (4)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

この例では、チャネルとポートで構成されるペア（1）が作成され、これらは文字列データ型の送信（2）に使用されます。 stream（）関数のプロトタイプには特に注意を払う必要があります。プロトタイプはfn stream <T：Send>（）->（Port、Chan）のようになります。 プロトタイプからわかるように、チャネルとポートはテンプレートタイプであり、一見、上記のコードからは明らかではありません。 この場合、転送されたデータのタイプは最初の使用に基づいて自動的に表示されます。 そのため、ユニット（3）をストリームに送信する行のコメントを解除すると、コンパイラーはエラーメッセージを表示します。

 error: mismatched types: expected `&'static str` but found `<VI0>` (expected &'static str but found integral variable
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Sendパラメータークラスには特に注意が払われます。つまり、現在のタスクの外部への転送をサポートするオブジェクトのみがストリームを使用して転送できます。



ストリームからデータを取得するには、recv（）関数を使用します。この関数は、データを返すか、表示されるまでタスクをブロックします。 上記の例を見ると、1つのタスクのフレームワーク内でスレッドを使用してメッセージを送信することには実用的な意味がないため、まったく役に立たないという疑念が忍び寄っています。 したがって、スレッドを使用してタスク間で情報を転送するなど、より実用的なものに進む価値があります。

 let value = vec::from_fn(5, |x| x + 1); // (1) let (server_chan, server_port) = stream(); // (2) let (client_chan, client_port) = stream(); // (3) do task::spawn { let val: ~[uint] = server_chan.recv(); // (4) let res = val.map(|v| {v+1}); client_port.send(res) // (5) } server_port.send(value); // (6) io::println(fmt!("Result: %?", client_chan.recv())); // (7)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ストリームを操作する際に最初に注意する必要があるのは、一意のポインターでアドレス指定された値を渡す必要があることです。from_fn（）（1）関数はそのような配列を作成するだけです。 ストリームは単方向であるため、要求の送信（2）と応答の受信（3）には2つのストリームが必要です。 recv（）関数を使用して、データはストリーム（4）から読み取られ、使用可能なデータがない場合、ストリームはタスクが表示されるまでブロックします。 結果をクライアントに送信するには、サーバーではなくクライアントストリームに属するsend（）（5）関数を使用します。 同様に、サーバータスクに送信するためのデータを処理する必要があります。それらは、サーバーポートに関連するsend（）関数を使用して書き込まれます（6）。 最後に、サーバータスクによって送信された結果がクライアントストリームから読み取られます（7）。



したがって、サーバーにメッセージを送信し、サーバー側でメッセージを受信するには、server_chan、server_portストリームが使用されます。 ストリームの単方向性のため、クライアントストリームは、client_chanとclient_portのペアで構成されるサーバー計算の結果を取得するために作成されました。

ストリーム共有

ストリームは単方向のデータ転送メカニズムですが、「one-receiver-many-senders」モードでの動作を保証するメカニズムがあるため、データを送信するユーザーごとに新しいストリームを作成する必要はありません。

 enum command { // (1) print_hello(int), stop } ... let (server_chan, server_port) = stream(); // (2) let (client_chan, client_port) = stream(); // (3) do spawn { // (4) let mut hello_count = 0; let mut done = false; while !done { let req: command = server_chan.recv(); // (5) match req { print_hello(client_id) => { println( fmt!("Hello from client #%d", client_id)); hello_count += 1; } stop => { println("Stop command received"); done = true; } } } client_port.send(hello_count); // (6) } let server_port = SharedChan::new(server_port); // (7) for i in range(0, 5) { let server_port = server_port.clone(); // (8) do spawn { server_port.send(print_hello(i)); // (9) } } server_port.send(stop); println(fmt!("Result: %?", client_chan.recv()));
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

このため、および「1リーダー1ライター」スキームの場合、サーバー（2）およびクライアント（3）のスレッドを作成し、サーバータスク（3）を実行する必要があります。 サーバータスクのロジックは非常に単純です：クライアントによって送信されたサーバーチャネルからデータを読み取り（9）、画面に要求の受信に関するメッセージを表示し、受信したprint_hello（5）要求の結果の数をクライアントストリームに送信します。 ライターが複数あるため、（7）Chanの代わりにSharedChanに変換してサーバーポートのタイプを変更し、clone（）メソッドを使用して各ライターのポート（8）の一意のコピーを作成する必要があります。 ポートでのさらなる作業は、前の例と変わりません：send（）メソッドを使用してデータをサーバー（9）に送信しますが、データが複数のタスクから同時に送信される点が異なります。



この例では、ストリームの操作方法の説明に加えて、1つのストリームを使用していくつかの異なるタイプのメッセージを送信する方法を示します。 ストリームによって送信されるデータのタイプはコンパイル段階で設定されるため、さまざまなタイプのデータを転送するには、シリアル化とそれに続くバイナリデータの転送（この方法については「オブジェクトの送信」セクションで説明）または列挙の転送（1）を使用する必要があります。 Rustの列挙は、その性質上、C言語またはVariant型の関連付けに似ており、ほとんどすべての高レベルプログラミング言語で何らかの形で存在します。

出荷オブジェクト

一意のポインターでアドレス指定された値を転送する必要が問題になる場合、flatpipesモジュールが役立ちます。 このモジュールを使用すると、シリアル化をサポートする配列またはオブジェクトの形式でバイナリデータを送受信できます。

 #[deriving(Decodable)] // (1) #[deriving(Encodable)] // (2) struct EncTest { val1: uint, val2: @str, val3: ~str } ... let (server_chan, server_port) = flatpipes::serial::pipe_stream(); // (3) do task::spawn { let value = @EncTest{val1: 1u, val2: @"test string 1", val3: ~"test string 2"}; server_port.send(value); // (4) } let val = server_chan.recv(); server_port.send(value); // (5)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

例からわかるように、フラットパイプの操作は非常に簡単です。 オブジェクトがフラットパイプを介して送信される構造は、serializable（1）およびdeserializable（2）として宣言する必要があります。 フラットパイプの作成（3）は、チャネルとポートを使用してメッセージを受信（4）および送信（5）するのと同じように、技術的には通常のストリームの作成と違いはありません。 フラットパイプとストリームの主な違いは、送信側でオブジェクトのディープコピーを作成することと、受信側で新しいオブジェクトを作成することです。 このアプローチのおかげで、通常のストリームと比較してフラットパイプで作業するオーバーヘッドが増加しますが、タスク間でデータを転送する能力は増加します。

高レベルのメッセージング抽象化

上記のほとんどの例では、2つのストリームが作成されます。1つはサーバーにデータを送信するためのもので、もう1つはサーバーからデータを受信するためのものです。 このアプローチは具体的なメリットをもたらさず、コードを無駄にするだけです。 この点で、モジュールextra：commが作成されました。これは、std :: commに対する高レベルの抽象化であり、単一ストリーム内での双方向通信を可能にするDuplexStreamが含まれています。 もちろん、DuplexStreamのソースコードを見ると、これは標準ストリームのペアに対する便利なアドオンに過ぎないことが明らかになります。

 let value = ~[1, 2, 3, 4, 5]; let (server, client) = DuplexStream(); // (1) do task::spawn { let val: ~[uint] = server.recv(); // (2) io::println(fmt!("Value: %?", val)); let res = val.map(|v| {v+1}); server.send(res) // (3) } client.send(value); // (4) io::println(fmt!("Result: %?", client.recv())); // (5)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

DuplexStreamを使用する場合、（1）2つの双方向ストリームの単一のペアが作成され、どちらもメッセージの送信と受信の両方に使用できます。 サーバーオブジェクトは、タスクのコンテキストによってキャプチャされ、サーバータスクでのメッセージの受信（2）と送信（3）、およびクライアントタスクでのクライアントオブジェクト（4,5）に使用されます。 DuplexStreamを使用する原理は、通常のストリームを使用する場合と変わりませんが、補助オブジェクトの数を減らすことができます。

アークモジュール

メッセージを送信するすべての魅力にもかかわらず、遅かれ早かれ、「複数のタスクから同時にアクセスする必要のある大きなデータ構造で何をすべきか？」という疑問が生じます。アプリケーション、およびそのメンテナンスは本当の悪夢に変わります。 そのような場合のために、Arcモジュールが作成されました。これにより、複数のタスクから同じオブジェクトへの共同アクセスを整理できます。

一意の読み取り専用ポインターを共有する

最初に、最も単純なケース-複数のタスクからの不変データへのアクセスの共有-に対処する必要があります。 Arc, (Atomically Reference-Counter) . ARC- pub fn new(data: T) -> Arc T .

 impl<T:Freeze+Send> Arc<T> { pub fn new(data: T) -> Arc<T> { ... } ... }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Send, , Freeze, T ( Rust deeply immutable objects).

 let data = arc::Arc::new(~[1, 2, 3, 4, 5]); // (1) let shared_data = data.clone(); // (2) do spawn { let val = shared_data.get(); // (3) println(fmt!("Shared array: %?", val)); } println(fmt!("Original array: %?", data.get())); // (4)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

, Arc, – . , , Arc (1), Arc (2), (3), (4) .

R/W

RWArc . , RWArc “ ”, , , , . , , RO , , RW , , Rust . : , .

 let data = arc::RWArc::new(~[1, 2, 3, 4, 5]); // (1) do 5.times { let reader = data.clone(); // (2) do spawn { do reader.read() |data| { // (3) io::println(fmt!("Value: %?", data)); // (4) } } } do spawn { do data.write() |data| { // (5) for x in data.mut_iter() { *x = *x * 2 } // (6) } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

(1) , RWArc, (4), (6). RWArc – read() (3) write() (5) . , RWArc, . , , (2) , .

?

, , , Arc RWArc Rust. Rust , . , , . Rust unsafe, , , , malloc, free, . Rust . , , «COMPLETELY UNSAFE» .

結論の代わりに

Rust , , . , Rust -, C C++, , . , .



, , , : -, , , -, – . , .