Concurrency¶ 並行性¶

Defining and Calling Asynchronous Functions¶ 非同期関数の定義と呼び出し¶

An asynchronous function or asynchronous method is a special kind of function or method that can be suspended while it’s partway through execution. This is in contrast to ordinary, synchronous functions and methods, which either run to completion, throw an error, or never return. An asynchronous function or method still does one of those three things, but it can also pause in the middle when it’s waiting for something. Inside the body of an asynchronous function or method, you mark each of these places where execution can be suspended. 非同期関数または非同期メソッドは、関数またはメソッドのある特別な種類です、それはそれが遂行の途中である間に中断されることが可能です。これは、普通の同期関数およびメソッドとは対照的です、それは完了するまで実行する、エラーをスローする、または決して復帰しないのどれかです。非同期の関数やメソッドは依然としてそれら３つのことの１つを行います、しかしそれはまた、それが何かを待っている時に途中で一時停止できます。非同期の関数やメソッドの本体の内部で、あなたは遂行が中断されることが可能であるそれら場所のそれぞれに印をつけます。

To indicate that a function or method is asynchronous, you write the async keyword in its declaration after its parameters, similar to how you use throws to mark a throwing function. If the function or method returns a value, you write async before the return arrow (->). For example, here’s how you might fetch the names of photos in a gallery: ある関数またはメソッドが非同期であることを指し示すために、あなたはasyncキーワードをそれの宣言の中でそれのパラメータの後に書きます、あなたがthrowsを使ってスロー関数を印する方法と同じように。関数またはメソッドが値を返すならば、あなたはasyncをその戻り矢印（->）の前に書きます。例えば、ここにあなたがあるギャラリーの写真の名前を取って来るかもしれない方法があります：

For a function or method that’s both asynchronous and throwing, you write async before throws. 非同期とスローの両方である関数やメソッドに対して、あなたはasyncをthrowsの前に書きます。

When calling an asynchronous method, execution suspends until that method returns. You write await in front of the call to mark the possible suspension point. This is like writing try when calling a throwing function, to mark the possible change to the program’s flow if there’s an error. Inside an asynchronous method, the flow of execution is suspended only when you call another asynchronous method—suspension is never implicit or preemptive—which means every possible suspension point is marked with await. 非同期メソッドを呼び出す時、遂行はそのメソッドが戻るまで中断されます。あなたは、awaitをその呼び出しの前に書くことで可能な中断地点を印します。これは、エラーがある場合のプログラムの流れに対する可能な変更を印するために、tryをスロー関数の呼び出しの時に書くことに似ています。非同期メソッドの内部では、遂行の流れは、あなたが別の非同期メソッドを呼び出す時にのみ中断されます — 中断は決して暗黙的または先制的ではありません — それが意味するのはあらゆる可能な中断地点はawaitで印されるということです。

For example, the code below fetches the names of all the pictures in a gallery and then shows the first picture: 例えば、下のコードは、あるギャラリーの全ての画像の名前を取ってきて、それから最初の画像を示します：

Because the listPhotos(inGallery:) and downloadPhoto(named:) functions both need to make network requests, they could take a relatively long time to complete. Making them both asynchronous by writing async before the return arrow lets the rest of the app’s code keep running while this code waits for the picture to be ready. listPhotos(inGallery:)およびdownloadPhoto(named:)関数の両方がネットワーク要請をする必要があることから、それらは完了するのに比較的に長い時間がかかる可能性があります。それらを両方ともasyncを戻り矢印の前に書くことによって非同期にすることは、アプリのもつコードの残りに動作を続けさせます、一方でこのコードは画像が利用可能になるのを待ちます。

To understand the concurrent nature of the example above, here’s one possible order of execution: 上の例の並行の本質を理解するために、ここに遂行の１つの起こりうる順番があります：

1. The code starts running from the first line and runs up to the first await. It calls the listPhotos(inGallery:) function and suspends execution while it waits for that function to return. コードは、最初の行から動作を開始します、そして最初のawaitに至るまで動作します。それはlistPhotos(inGallery:)関数を呼び出します、そしてその関数が戻るのをそれが待つあいだ遂行を中断します。
2. While this code’s execution is suspended, some other concurrent code in the same program runs. For example, maybe a long-running background task continues updating a list of new photo galleries. That code also runs until the next suspension point, marked by await, or until it completes. このコードの遂行が中断される間、何らかの他の並行性コードは同じプログラムの中で動作します。例えば、たぶん長期動作のバックグラウンドタスクは、新しい写真ギャラリーのリストの更新を続けます。そのコードはまた、awaitによって印される次の中断地点まで、またはそれが完了するまで動作します。
3. After listPhotos(inGallery:) returns, this code continues execution starting at that point. It assigns the value that was returned to photoNames. listPhotos(inGallery:)が返った後、このコードはその地点で開始して遂行を続けます。それは、返された値をphotoNamesに代入します。
4. The lines that define sortedNames and name are regular, synchronous code. Because nothing is marked await on these lines, there aren’t any possible suspension points. sortedNamesとnameを定義する行は、普通の、同期コードです。まったくawaitで印されるものがこれらの行にないので、可能な中断地点は何もありません。
5. The next await marks the call to the downloadPhoto(named:) function. This code pauses execution again until that function returns, giving other concurrent code an opportunity to run. 次のawaitは、downloadPhoto(named:)関数への呼び出しを印します。このコードは、その関数が返るまで再び遂行を一時停止します、他の並行性コードに動作する機会を与えて。
6. After downloadPhoto(named:) returns, its return value is assigned to photo and then passed as an argument when calling show(_:). downloadPhoto(named:)が返った後、それの戻り値はphotoに割り当てられます、そしてそれから引数としてshow(_:)を呼び出す時に渡されます。

The possible suspension points in your code marked with await indicate that the current piece of code might pause execution while waiting for the asynchronous function or method to return. This is also called yielding the thread because, behind the scenes, Swift suspends the execution of your code on the current thread and runs some other code on that thread instead. Because code with await needs to be able to suspend execution, only certain places in your program can call asynchronous functions or methods: あなたのコードの中のawaitで印されるそれら可能な中断地点が指し示すのは、コードの現在の断片が遂行を非同期の関数やメソッドが返るのを待っている間に一時停止するかもしれない、ということです。これはまた、スレッドの譲渡とも呼ばれます、なぜなら、シーンそれらの背後で、スウィフトはあなたのコードの遂行を現在のスレッド上で中断して、何らかの他のコードをそのスレッド上で代わりに実行するからです。awaitをもつコードは遂行を中断できる必要があることから、あなたのプログラムの中の特定の部分だけが非同期の関数やメソッドを呼び出すことが可能です：

• Code in the body of an asynchronous function, method, or property. 非同期の関数、メソッド、またはプロパティの本体の中のコード。
• Code in the static main() method of a structure, class, or enumeration that’s marked with @main. @mainで印される構造体、クラス、または列挙の静的main()メソッドの中のコード。
• Code in an unstructured child task, as shown in Unstructured Concurrency below. 下の構造化されない並行性の中で示されるような、ある構造化されない子タスクの中のコード。

Asynchronous Sequences¶ 非同期シーケンス¶

The listPhotos(inGallery:) function in the previous section asynchronously returns the whole array at once, after all of the array’s elements are ready. Another approach is to wait for one element of the collection at a time using an asynchronous sequence. Here’s what iterating over an asynchronous sequence looks like: 前の節でのlistPhotos(inGallery:)関数は、配列の持つ要素の全てが準備できた後に、配列全体を非同期に一度に返します。別の取り組み方は、非同期シーケンスを使用して一度にコレクションの１つの要素に対して待機することです。ここに、ある非同期シーケンスのすべてにわたって反復することがどのように見えるかがあります：

Instead of using an ordinary for-in loop, the example above writes for with await after it. Like when you call an asynchronous function or method, writing await indicates a possible suspension point. A for-await-in loop potentially suspends execution at the beginning of each iteration, when it’s waiting for the next element to be available. 普通のfor-inループを使う代わりに、上の例はforをそれの後のawaitと共に書きます。あなたが非同期関数やメソッドを呼び出すときのように、awaitを書くことは可能な中断地点を指し示します。for-await-inループは、潜在的に遂行を各反復の始まりで中断します、次の要素が利用可能になるのをそれが待っている場合は。

In the same way that you can use your own types in a for-in loop by adding conformance to the Sequence protocol, you can use your own types in a for-await-in loop by adding conformance to the AsyncSequence protocol. あなたがあなた独自の型をfor-inループにおいてSequenceプロトコルへの準拠を加えることによって使うのと同じ方法で、あなたはあなた独自の型をfor-await-inループにおいて使うことがAsyncSequenceプロトコルへの準拠を加えることによって可能です。

Calling Asynchronous Functions in Parallel¶ 非同期関数を並列に呼び出す¶

Calling an asynchronous function with await runs only one piece of code at a time. While the asynchronous code is running, the caller waits for that code to finish before moving on to run the next line of code. For example, to fetch the first three photos from a gallery, you could await three calls to the downloadPhoto(named:) function as follows: 非同期関数をawaitとともに呼び出すことは、ただコードの１断片を一度実行するだけです。ある非同期コードが動作している間、呼び出し側は、コードの次の行を実行するために移動する前に、そのコードが終了するのを待ちます。例えば、最初の３枚の写真をあるギャラリーから取ってくるには、あなたはdownloadPhoto(named:)関数への３つの呼び出しに対して待機します、次のように：

This approach has an important drawback: Although the download is asynchronous and lets other work happen while it progresses, only one call to downloadPhoto(named:) runs at a time. Each photo downloads completely before the next one starts downloading. However, there’s no need for these operations to wait—each photo can download independently, or even at the same time. この取り組みはある重要な欠点があります：ダウンロードが非同期でありそれが進捗する間に他の仕事が起こるに任せるとはいえ、ただ１つのdownloadPhoto(named:)への呼び出しだけが一度に動作します。各写真は、次のものがダウンロードを開始する前に、完全にダウンロードされます。しかしながら、それら演算が待機する必要はありません — 各写真は独立して、または同時にさえダウンロード可能です。

To call an asynchronous function and let it run in parallel with code around it, write async in front of let when you define a constant, and then write await each time you use the constant. 非同期関数を呼び出してそしてそれをそのまわりのコードと並列に動作させるには、あなたが定数を定義する時にasyncをletの前に書いてください、それからあなたがその定数を使うたびごとにawaitを書いてください。

In this example, all three calls to downloadPhoto(named:) start without waiting for the previous one to complete. If there are enough system resources available, they can run at the same time. None of these function calls are marked with await because the code doesn’t suspend to wait for the function’s result. Instead, execution continues until the line where photos is defined—at that point, the program needs the results from these asynchronous calls, so you write await to pause execution until all three photos finish downloading. この例において、downloadPhoto(named:)への３つの呼び出し全ては、前のものが完了するのを待つことなしに開始します。十分なシステムリソースが利用可能ならば、それらは同時に動作可能です。これらの関数呼び出しのどれひとつとしてawaitで印されません、なぜならコードは関数の結果を待つために中断しないからです。代わりに、遂行はphotosが定義されるところの行まで継続します — その時点で、プログラムはそれら非同期呼び出しからの結果を必要とします、なのであなたはawaitを書いて、３枚の写真全てがダウンロードを終了するまで遂行を中断します。

Here’s how you can think about the differences between these two approaches: ここに、あなたがこれら２つの取り組みの間の違いについてどのように考えることが可能かがあります：

• Call asynchronous functions with await when the code on the following lines depends on that function’s result. This creates work that is carried out sequentially. 非同期関数をawaitと共に呼び出してください、続く行でのコードがその関数の結果に依存する場合は。これは、逐次的に実施される仕事を作成します。
• Call asynchronous functions with async-let when you don’t need the result until later in your code. This creates work that can be carried out in parallel. 非同期関数をasync-letと共に呼び出してください、あなたが結果をあなたのコードにおいてもっと後まで必要としない場合は。これは、並列に実施されることができる仕事を作成します。
• Both await and async-let allow other code to run while they’re suspended. awaitとasync-letの両方は、それらが中断される間に他のコードが動作するのを許可します。
• In both cases, you mark the possible suspension point with await to indicate that execution will pause, if needed, until an asynchronous function has returned. 両方の場合において、あなたは可能な中断地点をawaitで印することでその遂行が一時停止することを指し示します、必要ならば、非同期関数が返ってしまうまで。

You can also mix both of these approaches in the same code. あなたはまた、これら取り組みの両方を同じコードにおいて混ぜることができます。

Tasks and Task Groups¶ タスクとタスクグループ¶

A task is a unit of work that can be run asynchronously as part of your program. All asynchronous code runs as part of some task. The async-let syntax described in the previous section creates a child task for you. You can also create a task group and add child tasks to that group, which gives you more control over priority and cancellation, and lets you create a dynamic number of tasks. タスクは、ひとつの仕事の単位です、それは非同期にあなたのプログラムの一部として実行されることが可能なものです。全ての非同期コードは、あるタスクの一部として動作します。前の節で記述されるasync-let構文は、子タスクをあなたの代わりに作成します。あなたはまた、タスクグループを作成して、子タスクそれらをそのグループに加えることができます、それはあなたに優先と取消に対するさらなる制御を与えます、そしてあなたに動的な数のタスクを作成させます。

Tasks are arranged in a hierarchy. Each task in a task group has the same parent task, and each task can have child tasks. Because of the explicit relationship between tasks and task groups, this approach is called structured concurrency. Although you take on some of the responsibility for correctness, the explicit parent-child relationships between tasks lets Swift handle some behaviors like propagating cancellation for you, and lets Swift detect some errors at compile time. タスクは、ある階層の中にきちんと並べられます。タスクグループの中の各タスクは、同じ親タスクを持ちます、そして各タスクは子タスクいくつかを持つことができます。タスクとタスクグループの間のこの明確な関係のために、この取り組みは構造化された並行性と呼ばれます。あなたが正しさに対する責任の一部を負うとはいえ、タスク間の明確な親子関係は、取り消しをあなたに代わって伝播することのようないくつかの挙動をスウィフトに取り扱わせます。

For more information about task groups, see TaskGroup. タスクグループについての更なる情報として、TaskGroupを見てください。

Actors¶ アクター¶

Like classes, actors are reference types, so the comparison of value types and reference types in Classes Are Reference Types applies to actors as well as classes. Unlike classes, actors allow only one task to access their mutable state at a time, which makes it safe for code in multiple tasks to interact with the same instance of an actor. For example, here’s an actor that records temperatures: クラスのように、アクターは参照型です、なのでクラスは参照型ですにおける値型と参照型の比較がクラスと同様にアクターに適用されます。クラスと異なり、アクターそれらは一度にただ１つのタスクにだけそれらの可変状態へのアクセスを許可します、それはコードにとって複数タスクにおいてあるアクターの同じインスタンスと相互作用することを安全なものにします。例えば、ここに温度を記録するあるアクターがあります：

You introduce an actor with the actor keyword, followed by its definition in a pair of braces. The TemperatureLogger actor has properties that other code outside the actor can access, and restricts the max property so only code inside the actor can update the maximum value. あなたはあるアクターをactorキーワード、それに続けて一対の波カッコの中のそれの定義で導入します。TemperatureLoggerアクターはプロパティいくつかを持ちます、それらはそのアクターの外側の他のコードがアクセスできます、そしてmaxプロパティを制限します、それでアクター内部のコードだけが最大値を更新することが可能です。

You create an instance of an actor using the same initializer syntax as structures and classes. When you access a property or method of an actor, you use await to mark the potential suspension point—for example: あなたは、アクターのインスタンスを構造体およびクラスと同じ初期化構文を使って作成します。あなたがアクターのプロパティまたはメソッドにアクセスする時、あなたはawaitを使うことで潜在的な中断地点を印します — 例えば：

In this example, accessing logger.max is a possible suspension point. Because the actor allows only one task at a time to access its mutable state, if code from another task is already interacting with the logger, this code suspends while it waits to access the property. この例において、logger.maxへのアクセスは、ある可能な中断地点です。アクターが一度に１つのタスクだけにそれの可変状態へのアクセスを許可することから、別のタスクからのコードが既にloggerと相互作用しているならば、このコードはそれがプロパティにアクセスするために待つ間ずっと中断します。

In contrast, code that’s part of the actor doesn’t write await when accessing the actor’s properties. For example, here’s a method that updates a TemperatureLogger with a new temperature: 対照的に、アクターの一部であるコードは、awaitをそのアクターのもつプロパティにアクセスする時に書きません。例えば、ここにあるメソッドがあります、それはTemperatureLoggerを新しい温度で更新します：

The update(with:) method is already running on the actor, so it doesn’t mark its access to properties like max with await. This method also shows one of the reasons why actors allow only one task at a time to interact with their mutable state: Some updates to an actor’s state temporarily break invariants. The TemperatureLogger actor keeps track of a list of temperatures and a maximum temperature, and it updates the maximum temperature when you record a new measurement. In the middle of an update, after appending the new measurement but before updating max, the temperature logger is in a temporary inconsistent state. Preventing multiple tasks from interacting with the same instance simultaneously prevents problems like the following sequence of events: update(with:)メソッドは既にアクター上で動作しています、なのでそれはmaxのようなプロパティへのそれのアクセスをawaitで印しません。このメソッドはまた、なぜアクターそれらは一度にただ１つのタスクだけにそれらの可変状態との相互作用を許可するのかの理由の１つを示します：いくつかの更新をアクターのもつ状態に対してすることは一時的に不変式を壊します。TemperatureLoggerアクターは温度それらのリストと最大温度を追跡し続けます、そしてそれは最大温度をあなたが新しい測定を記録する時に更新します。更新の中途において、新しい測定を追加した後しかしmaxを更新する前に、TemperatureLoggerは一時的な矛盾状態に置かれます。複数のタスクが同じインスタンスと同時に相互作用するのを防ぐことは、以下の一連の出来事のような問題を防ぎます：

1. Your code calls the update(with:) method. It updates the measurements array first. あなたのコードがupdate(with:)メソッドを呼び出します。それはmeasurements配列を最初に更新します。
2. Before your code can update max, code elsewhere reads the maximum value and the array of temperatures. あなたのコードがmaxを更新可能になる前に、コードがどこか他のところで最大値と温度配列とを読み出します。
3. Your code finishes its update by changing max. あなたのコードは、その更新をmaxを変更することによって終了します。

In this case, the code running elsewhere would read incorrect information because its access to the actor was interleaved in the middle of the call to update(with:) while the data was temporarily invalid. You can prevent this problem when using Swift actors because they only allow one operation on their state at a time, and because that code can be interrupted only in places where await marks a suspension point. Because update(with:) doesn’t contain any suspension points, no other code can access the data in the middle of an update. この場合には、どこか他で動作しているコードは正しくない情報を読み出します、なぜならアクターへのそれのアクセスは、update(with:)への呼び出しの中途に、そのデータが一時的に正しくなかった間に、挟み込まれたからです。あなたはこの問題を防ぐことがスウィフトのアクターを使っている場合は可能です、なぜならそれらの状態に関して一度に１つの演算が許可されるだけだからです、そしてなぜならそのコードが割り込まれるのが可能なのはただawaitが中断地点を印するところにおいてのみだからです。update(with:)がまったく中断地点を含まないことから、１つとして他のコードは更新の中途でデータにアクセスできません。

If you try to access those properties from outside the actor, like you would with an instance of a class, you’ll get a compile-time error; for example: あなたがそれらプロパティにアクターの外側からアクセスを、あなたがクラスのインスタンスでするように、試みるならば、あなたはコンパイル時エラーを得るでしょう；例えば：

Accessing logger.max without writing await fails because the properties of an actor are part of that actor’s isolated local state. Swift guarantees that only code inside an actor can access the actor’s local state. This guarantee is known as actor isolation. logger.maxにawaitを書くことなくアクセスすることは失敗します、なぜならアクターのプロパティはそのアクターのもつ隔離されたローカルな状態の一部だからです。スウィフトは、あるアクター内部のコードだけが、そのアクターのもつローカル状態にアクセス可能であることを保証します。この保証は、アクター隔離（アクターアイソレーション）として知られます。