Scheduler_(プログラミング)

ウィキペディア

Scheduler (プログラミング)

出典: フリー百科事典『ウィキペディア（Wikipedia）』 (2024/08/11 12:03 UTC 版)

この項目では、プログラミングにおける「Scheduler」について説明しています。 オペレーティングシステムでの「Scheduler」については「スケジューリング」をご覧ください。

Scheduler（スケジューラ）とは、プログラミングにおいてタスクやプロセスの実行順序を管理する役割を果たす重要なコンポーネントである^[1][2][3][4]。特に、非同期処理やリアクティブプログラミングにおいては、効率的なタスク管理やリソースの最適化を実現するために不可欠な要素である。

Schedulerの歴史は、オペレーティングシステムの発展と密接に関連しており、初期のコンピュータシステムから現在に至るまで、様々な形式で進化してきた^[5][6][7][8]。プログラミングパラダイムの変遷に伴い、Schedulerの役割も変化し続けている。

Schedulerの基本概念には、タスクスケジューリングやスレッドの管理、プロセスのスケジューリングが含まれる^{[9][10][11][12]}。これらの概念を理解することで、プログラムのパフォーマンスや効率性を向上させることが可能となる。

Schedulerには、プリエンプティブスケジューラ（Preemptive Scheduler）やノンプリエンプティブスケジューラ（Non-Preemptive Scheduler）、リアルタイムスケジューラ（Real-Time Scheduler）など、異なる種類が存在する^{[13][14][15][16]}。それぞれのSchedulerは、異なるユースケースやシステム要件に対応して設計されている。

非同期処理におけるSchedulerは、イベントループやコルーチンといったメカニズムと連携し、効率的なタスク管理を実現する^[3][17]。リアクティブプログラミングにおいても、Schedulerはオブザーバブルとオブザーバーの連携を管理し、並行処理の最適化をサポートする。

スケジューリングアルゴリズムには、先着順スケジューリング（英: First-Come, First-Served Scheduling）や最短ジョブ優先（英: Shortest Job First）、ラウンドロビンスケジューリング（Round-Robin Scheduling、RR）、優先度スケジューリング（英: Priority Scheduling）などがあり、それぞれのアルゴリズムが特定のシナリオに適用される^{[1][5][18][19]}。

プログラミング言語におけるSchedulerの実装としては、PythonのasyncioモジュールやJavaScriptのイベントループ、JavaのExecutorServiceなどが挙げられる^{[20][21][22][23]}。これらの実装を利用することで、Schedulerの機能をプログラム内で活用できる。

Schedulerの応用分野は広く、リアルタイムシステムやデータベーストランザクション、分散システムやクラウドコンピューティングにおいて重要な役割を果たしている^{[2][16][24][25]}。

Schedulerのパフォーマンスと最適化は、プログラムの効率性に直接影響するため、オーバーヘッドの管理やベンチマークを通じて調整が行われるべきである^{[26][27][28][29]}。

このページでは、Schedulerの概要、歴史、基本概念、種類、非同期処理における役割、リアクティブプログラミングにおける役割、スケジューリングアルゴリズム、プログラミング言語における実装、応用分野、パフォーマンスと最適化について詳述する。

概要

Schedulerは、コンピュータシステムやプログラム内でタスクやプロセスの実行順序を管理し、効率的なリソースの使用とシステム全体の性能向上を目指す機構である^{[1][5][16][19]}。Schedulerは、シングルスレッド環境からマルチスレッドや分散システムまで、様々なコンテキストで使用される。特に、非同期処理やリアクティブプログラミングの文脈では、複数のタスクが同時に進行するため、Schedulerの役割がより重要となる。

Schedulerの定義

Schedulerは、タスクの優先順位や依存関係を考慮し、システムのリソースを最適に配分するためのアルゴリズムやメカニズムの総称である^{[6][7][11][30]}。一般的には、スレッド、プロセス、タスクの実行順序を決定し、システムの効率を最大化することを目的としている。Schedulerは、オペレーティングシステムのカーネル内で動作するものから、アプリケーションレベルでのタスク管理に使用されるものまで、多岐に渡る形態をもつ。

プログラミングにおけるSchedulerの役割

プログラミングにおいて、Schedulerはタスクやプロセスの管理を通じてシステムの性能を最大限に引き出す役割を担う^{[2][5][13][25]}。これには、プロセッサの効率的な使用、タスク間の競合の解消、そしてリアルタイム性の要求に応じた適切なスケジューリングが含まれる。また、非同期処理やリアクティブプログラミングでは、イベント駆動型のモデルにおいてタスクの順序を制御し、システム全体のスループットや応答性を向上させる。Schedulerは、これらのタスクを効果的に管理することで、システムの安定性と効率性を維持することができる。

歴史

Schedulerは、コンピュータ科学の初期から存在し、その役割はオペレーティングシステムの進化と共に発展してきた^{[1][6][7][30]}。当初のコンピュータシステムでは、Schedulerは比較的単純なタスクスケジューリングを行うだけであったが、コンピュータの処理能力が向上し、タスクの複雑性が増すにつれて、Schedulerも高度な機能をもつようになった。特に、1960年代から1970年代にかけてマルチタスクシステムやリアルタイムシステムの登場により、効率的なスケジューリングがシステムの性能に直結するようになった。

Schedulerの発展

Schedulerの発展は、コンピュータアーキテクチャやオペレーティングシステムの進化と密接に関連している。1950年代から1960年代にかけて、初期のオペレーティングシステムでは、先着順スケジューリング（英: First-Come, First-Served Scheduling）が主に使用されていた^{[1][5][7][18]}。1970年代に入ると、マルチプログラミングの普及により、ラウンドロビンスケジューリング（Round-Robin Scheduling、RR）や優先度スケジューリング（英: Priority Scheduling）など、より複雑なアルゴリズムが導入され始めた^[1][5][6][7]。

1980年代以降、リアルタイムシステムや並列処理の重要性が増す中で、プリエンプティブスケジューラ（Preemptive Scheduler）やリアルタイムスケジューラ（Real-Time Scheduler）の概念が確立された^{[1][2][6][13]}。これにより、タスクの緊急度やリソースの競合状況に応じて柔軟にタスクを切り替えることが可能となり、システムのレスポンスが大幅に向上した。

2010年代に入り、非同期処理やリアクティブプログラミングが広く採用されるようになると、Schedulerはイベント駆動型アーキテクチャや分散システムにおいても重要な役割を果たすようになった^[3][31]。これに伴い、スケジューリングアルゴリズムもさらに進化し、タスクの効率的な管理とリソースの最適化が可能となっている。

主要なプログラミングパラダイムにおけるSchedulerの位置付け

プログラミングパラダイムの変遷に伴い、Schedulerの役割も変化してきた^{[1][32][33][34]}。手続き型プログラミングでは、Schedulerは主にオペレーティングシステムの一部として機能し、タスクの実行順序を決定していた。一方、オブジェクト指向プログラミングが登場すると、スレッドやプロセスの管理がクラスやオブジェクトのメソッドとして実装されるようになり、Schedulerの設計に柔軟性が求められるようになった。

非同期処理が普及する2010年代以降、イベントループと協調して動作するSchedulerが開発され、複数の非同期タスクを効率的に管理する仕組みが整った^{[3][4][21][31]}。また、リアクティブプログラミングでは、データフローに基づいたタスクの実行順序を制御するSchedulerが重要な役割を果たしている。このように、各パラダイムにおいてSchedulerは、タスク管理の中心的な要素として機能し、システムの効率性と安定性を支えている。

Schedulerの基本概念

Schedulerの基本概念は、タスク、スレッド、プロセスの効率的な管理と実行順序の決定にある^[1][5][6][9]。これらはコンピュータシステムのリソースを最大限に活用し、同時に複数の作業を円滑に行うための基盤となる。Schedulerは、システム全体のパフォーマンスと応答性を最適化するために、これらの要素を適切に調整する役割を担っている。

タスクスケジューリング

タスクスケジューリングは、個々のタスクがいつ実行されるかを決定するプロセスである^{[1][2][6][13]}。タスクは通常、特定の時間やリソースに依存して実行されるため、Schedulerはこれらの依存関係を考慮しつつ、システム全体の効率を最大化するようにタスクをスケジューリングする。タスクスケジューリングは、シンプルなシステムでは静的に設定されることが多いが、複雑なシステムでは動的にスケジューリングが行われる。これにより、リアルタイムの状況に応じた最適なタスク実行順序が確保される。

スレッドとプロセスのスケジューリング

スレッドとプロセスのスケジューリングは、Schedulerが特定のスレッドやプロセスをどのような順序で実行するかを決定する機能である^[1][5][6][9]。スレッドはプロセス内で実行される単位であり、複数のスレッドが並行して動作することで、システムの並列処理能力を高めることができる。一方、プロセスは独立した実行環境をもち、それぞれが独自のメモリ空間とリソースを管理する。Schedulerはこれらのスレッドやプロセスを最適に配置し、リソースの競合を避けながらシステムのパフォーマンスを維持する役割を果たす。

スレッドスケジューリングには、プリエンプティブスケジューリング（Preemptive Scheduling）とノンプリエンプティブスケジューリング（Non-Preemptive Scheduling）の二種類がある^{[1][5][6][19]}。プリエンプティブスケジューリングでは、Schedulerが実行中のスレッドを中断し、他のスレッドにリソースを割り当てることができる。一方、ノンプリエンプティブスケジューリングでは、スレッドが自発的に実行を終了するまで、他のスレッドが実行を待つ必要がある。

プロセス管理とスケジューリングの関係

プロセス管理とスケジューリングは密接に関連している^{[1][5][6][19]}。プロセス管理は、システム内の各プロセスのライフサイクルを管理し、実行中のプロセスの状態を追跡する機能である。Schedulerは、このプロセス管理の一環として、各プロセスの実行順序を決定し、CPU時間やメモリなどのリソースを効率的に配分する。

プロセス管理とスケジューリングの関係は、特にマルチタスクシステムにおいて重要である^{[1][5][6][19]}。複数のプロセスが同時に実行される環境では、Schedulerが適切なタイミングでプロセスを切り替え、各プロセスが公平にリソースを利用できるようにする。これにより、システムのスループットが最大化され、レスポンスタイムが最小化される。適切なプロセススケジューリングにより、システムは過負荷状態を回避し、安定した動作を維持することができる。

Schedulerの種類

Schedulerには、異なるユースケースやシステム要件に応じて様々な種類が存在する^{[1][5][6][13]}。主に、プリエンプティブスケジューラ（Preemptive Scheduler）、ノンプリエンプティブスケジューラ（Non-Preemptive Scheduler）、リアルタイムスケジューラ（Real-Time Scheduler）の三つのカテゴリに分類される。それぞれのSchedulerは、特定のシステム環境やタスク管理の要件に応じて設計されており、システムの性能や応答性に大きな影響を与える。

プリエンプティブスケジューラ（Preemptive Scheduler）

プリエンプティブスケジューラは、現在実行中のタスクを中断して、他のタスクを実行することができるSchedulerである^{[2][5][6][13]}。この中断（プリエンプション）は、スケジューリングアルゴリズムによって決定され、通常、タスクの優先度や経過時間などが考慮される。

マルチタスク環境での使用例

プリエンプティブスケジューラは、マルチタスク環境で特に有効である^{[1][5][6][19]}。例えば、オペレーティングシステムでは、多数のユーザーやアプリケーションが同時にリソースを要求する状況が頻繁に発生する。この場合、プリエンプティブスケジューラは、リソースの効率的な配分を行い、ユーザーやアプリケーションがスムーズに動作するように調整する。例えば、Windows^[35][36]やLinux^[9][37]などの一般的なオペレーティングシステムでは、このタイプのSchedulerが標準的に使用されている。

コンテキストスイッチとプリエンプション

タスクの中断（プリエンプション）が発生すると、実行中のタスクが中断され、別のタスクに切り替わる^[1][5][6][9]。この切り替えの過程をコンテキストスイッチと呼ぶ。コンテキストスイッチでは、現在のタスクの状態（レジスタの値やメモリの内容など）が保存され、新しいタスクの状態がロードされる。コンテキストスイッチはオーバーヘッドを伴うが、プリエンプティブスケジューラはこのコストを最小限に抑えつつ、システム全体の応答性を向上させる。

ノンプリエンプティブスケジューラ（Non-Preemptive Scheduler）

ノンプリエンプティブスケジューラは、タスクが自発的に終了するまで他のタスクに切り替わらないSchedulerである^[1][5][6][9]。このタイプのSchedulerは、タスク間の競合が少なく、比較的シンプルなシステムで使用されることが多い。

単純なタスク管理における利点

ノンプリエンプティブスケジューラの主な利点は、コンテキストスイッチが発生しないため、オーバーヘッドが少ない点である^{[1][5][6][13]}。これにより、システムの全体的なパフォーマンスが安定し、予測可能な動作が保証される。また、タスクの実行順序が明確であるため、デバッグが容易である。

典型的なユースケース

ノンプリエンプティブスケジューラは、タスクが短時間で終了する場合や、タスク間の相互依存が少ないシステムに適している^{[1][2][38][39]}。例えば、シンプルな組み込みシステムやシングルタスクのアプリケーションでは、このタイプのSchedulerが使用されることが多い。また、教育目的でスケジューリングの基本を学ぶ際にも、ノンプリエンプティブスケジューラはよく使用される^{[1][5][6][18]}。

リアルタイムスケジューラ（Real-Time Scheduler）

リアルタイムスケジューラは、特定のタイミングでタスクを実行する必要があるリアルタイムシステムで使用されるSchedulerである^{[2][5][6][13]}。このタイプのSchedulerは、タスクの緊急度やデッドラインを考慮し、リアルタイム性を保証するように設計されている。

リアルタイムシステムにおける重要性

リアルタイムシステムでは、タスクの遅延やタイミングのズレがシステムの全体的な性能や安全性に重大な影響を与えることがある^{[2][5][13][40]}。このため、リアルタイムスケジューラは、タスクの優先度やデッドラインに基づいて厳密にスケジューリングを行い、システムが要求されるタイミングで確実にタスクを実行するようにする。このタイプのSchedulerは、航空宇宙産業^[40]、医療機器^[41]、自動車の制御システム^[42]など、ミッションクリティカルなシステムで広く使用されている。

固定優先度スケジューリングと動的優先度スケジューリング

リアルタイムスケジューラには、タスクの優先度を固定してスケジューリングする固定優先度スケジューリング（英: Fixed-Priority Scheduling）と、タスクの状況に応じて優先度を動的に変更する動的優先度スケジューリング（英: Dynamic-Priority Scheduling）の二つの主要な方式がある^{[2][5][6][13]}。

固定優先度スケジューリングは、事前に設定された優先度に基づいてタスクをスケジューリングする方式で、システムの動作が予測しやすい^{[2][5][6][13]}。しかし、優先度逆転の問題が発生する可能性がある。一方、動的優先度スケジューリングは、タスクの実行状況やシステムの負荷に応じて優先度を動的に変更することで、より柔軟かつ効率的にタスクを管理する。最も一般的な動的優先度スケジューリングアルゴリズムとしては、最早期限優先（英: Earliest Deadline First、EDF）がある。これは、デッドラインに最も近いタスクを優先的に実行することで、リアルタイム性を最大限に確保する方法である。

非同期処理におけるScheduler

非同期処理におけるSchedulerは、複数のタスクが同時に進行する状況で、効率的にタスクを管理するために重要な役割を果たす^{[3][4][21][43]}。非同期処理では、タスクが並行して実行されるが、それらのタスクは完全に同時に実行されるわけではない。Schedulerは、このようなタスクの実行順序を調整し、システム全体の効率と応答性を向上させる。

イベントループの役割

イベントループは、非同期処理の中心的なコンポーネントであり、タスクが完了するのを待ちながら、次のタスクをスケジューリングする役割を担う^{[4][21][43][44]}。イベントループは、入力やタイマーなどのイベントを監視し、対応するコールバックを実行することで、非同期タスクを処理する。イベントループが効率的に機能するためには、Schedulerが適切にタスクを管理し、リソースを最適に配分することが必要である。

例えば、JavaScriptのイベントループは、シングルスレッドで動作するが、非同期タスクを効率的に処理することで、ユーザーインターフェースの応答性を維持しつつ、バックグラウンドで複雑な処理を実行することができる^{[21][45][46][47]}。Pythonのasyncioモジュールも同様に、イベントループを用いて非同期タスクを管理し、システムの効率を最大化している^{[17][20][48][49]}。

コルーチンとスケジューラ

コルーチンは、非同期処理を実現するためのプログラミング構造であり、Schedulerによって管理されるタスクの一種である^{[8][17][50][51]}。コルーチンは、通常の関数とは異なり、一時停止や再開が可能であり、非同期タスクを簡単に記述することができる。

コルーチンは、Schedulerによって適切なタイミングで実行され、他のタスクと並行して進行する^[17][20]。Schedulerは、コルーチンの状態を監視し、必要に応じて他のタスクにリソースを割り当てる。これにより、複数の非同期タスクが効率的に管理され、システム全体の応答性が向上する。

例えば、Pythonのasyncioモジュールでは、async defによって定義されたコルーチンが非同期タスクとしてSchedulerに登録され、イベントループ内で適切にスケジューリングされる^[17][48]。これにより、I/O待機などのブロッキングを回避し、スムーズな非同期処理が可能となる。

コールバックメカニズムとの連携

コールバックは、特定のイベントが発生した際に実行される関数であり、非同期処理において重要な役割を果たす^{[21][44][47][52]}。Schedulerは、イベントループ内でコールバックを適切なタイミングで呼び出すことで、非同期タスクを処理する。

コールバックメカニズムは、特にシンプルな非同期タスクの管理に適しているが、タスクが複雑になるとコールバックのネスト（いわゆる「コールバック地獄」）が発生しやすくなる^{[21][45][46][52]}。このため、Schedulerは、コールバックの実行順序を適切に管理し、システム全体のタスクフローを制御する必要がある。

例えば、JavaScriptでは、setTimeoutやPromiseを利用した非同期処理が一般的であり、これらの非同期タスクはSchedulerによって管理され、イベントループ内で適切なタイミングでコールバックが実行される^{[21][45][46][52]}。これにより、ユーザーの操作や外部からの入力に対して迅速に応答することができる。

総じて、非同期処理におけるSchedulerは、イベントループ、コルーチン、コールバックメカニズムと連携しながら、システムのタスクを効率的に管理し、システム全体のパフォーマンスとユーザー体験を向上させる役割を果たしている。

リアクティブプログラミングにおけるScheduler

リアクティブプログラミングとは、データフローの変化に応じてリアルタイムで応答を行うプログラミングパラダイムである^{[3][31][53][54]}。このコンテキストにおいて、Schedulerは、非同期イベントやデータストリームの処理を効率的に管理するために不可欠な要素である。Schedulerは、リアクティブシステム内で複数のデータフローを調整し、システム全体のスループットと応答性を最適化する。

オブザーバブルとオブザーバーの連携

リアクティブプログラミングでは、オブザーバブル（Observable）とオブザーバー（Observer）が一般的に使用される^{[3][31][53][54]}。オブザーバブルはデータやイベントのストリームを提供し、オブザーバーはその変化を監視し、必要に応じて反応する。Schedulerは、この連携を調整し、イベントの発行タイミングやオブザーバーへの通知タイミングを管理する。

Schedulerが適切に機能することで、オブザーバブルのデータフローがスムーズにオブザーバーに伝達され、システム全体のリアクティブ（敏感）な応答が保証される^{[3][31][53][55]}。これにより、リアクティブシステムは、ユーザーの操作や外部のイベントに対して迅速かつ効率的に反応できるようになる。

サブスクリプションの管理

リアクティブプログラミングにおいて、サブスクリプションはオブザーバブルとオブザーバーの関係を管理する重要な要素である^{[3][31][53][54]}。サブスクリプションは、オブザーバブルからのデータやイベントのストリームをオブザーバーに渡す契約を意味し、Schedulerはこのサブスクリプションのライフサイクルを管理する。

具体的には、Schedulerはサブスクリプションの開始、維持、終了のタイミングを制御し、必要に応じてサブスクリプションをキャンセルしたり、再スケジューリングを行ったりする^{[3][31][53][54]}。これにより、不要なリソースの消費を防ぎ、システムの効率を高めることができる。また、Schedulerは、複数のサブスクリプションを適切に管理し、異なるオブザーバー間の競合やリソースの重複利用を最小限に抑える役割も果たしている。

並行処理とSchedulerの役割

リアクティブプログラミングでは、データやイベントのストリームが複数同時に発生することが一般的であり、これらを効率的に処理するためには並行処理が必要となる^{[3][53][54][55]}。Schedulerは、これらの並行するタスクを管理し、適切なタイミングで実行する役割を担う。

並行処理において、Schedulerはタスク間の優先度を調整し、リソースの競合を回避しつつ、全体的なシステム性能を最大化する^{[3][53][56][57]}。例えば、リアクティブプログラミングライブラリのRxJava^[3][53]やRxJS^[56][57]では、Schedulerを利用して複数のデータストリームを並行して処理し、各ストリームのタスクを効率的にスケジューリングする。このように、Schedulerはリアクティブプログラミングにおける並行処理の中心的な役割を果たし、システム全体のリアクティブ（敏感）な応答性と効率性を支えている。

総じて、リアクティブプログラミングにおけるSchedulerは、オブザーバブルとオブザーバーの連携、サブスクリプションの管理、そして並行処理の調整を通じて、リアルタイムなデータ処理を実現し、システム全体のパフォーマンスと安定性を向上させる重要な要素である。

スケジューリングアルゴリズム

スケジューリングアルゴリズムは、タスクやプロセスを効率的に管理するために、実行順序やリソース割り当てを決定するルールやメカニズムのことである^{[1][5][6][18]}。これらのアルゴリズムは、システムの性能や応答性に直接影響を与えるため、適切な選択が重要である。スケジューリングアルゴリズムには、先着順スケジューリング（英: First-Come, First-Served Scheduling、FCFS）、最短ジョブ優先（英: Shortest Job First、SJF）、ラウンドロビンスケジューリング（Round-Robin Scheduling、RR）、優先度スケジューリング（英: Priority Scheduling）などが存在する。それぞれのアルゴリズムは、特定のシナリオに最適化されており、システムの特性や要件に応じて選択される。

先着順スケジューリング（First-Come, First-Served Scheduling、FCFS）

先着順スケジューリング（英: First-Come, First-Served Scheduling、FCFS）は、最も基本的でシンプルなスケジューリングアルゴリズムの一つである^{[1][5][6][18]}。このアルゴリズムでは、タスクが到着した順序に従って実行される。FCFSは、待ち時間が最も短いタスクを最初に処理するため、公平なアルゴリズムと見なされている。

シンプルさとその限界

FCFSの最大の利点は、そのシンプルさと容易な実装である^{[1][5][6][58]}。このアルゴリズムは、特定の優先度やリソース要件を考慮する必要がなく、到着順にタスクを処理するため、予測可能な動作を保証する。しかし、このシンプルさには限界がある。特に、長時間実行されるタスクが先に来た場合、後続のタスクが長時間待たされることになる（いわゆる「コンボイ効果」）。このため、システムの応答性が低下し、リアルタイム性が求められるシステムには適さない。

最短ジョブ優先（Shortest Job First、SJF）

最短ジョブ優先（英: Shortest Job First、SJF）は、実行時間が最も短いタスクを優先的に処理するスケジューリングアルゴリズムである^{[1][5][6][58]}。SJFは、平均待ち時間を最小化することを目的としており、タスクの長さが事前に分かっている場合に最適なアルゴリズムとされている。

ジョブの長さ予測とSchedulerの調整

SJFの効果的な運用には、タスクの実行時間を正確に予測する能力が求められる^{[1][5][6][58]}。しかし、ジョブの長さを事前に予測することは困難であるため、実際のシステムでは近似やヒューリスティックな手法を用いて予測が行われることが多い。予測の誤りが大きい場合、短いジョブが後回しにされ、システム全体の効率が低下するリスクがある。SJFは、タスクが静的で実行時間が安定している環境に適しているが、動的で予測が難しいタスクが多い環境ではその有効性が限定される。

ラウンドロビンスケジューリング（Round-Robin Scheduling、RR）

ラウンドロビンスケジューリング（Round-Robin Scheduling、RR）は、各タスクに一定の「時間スライス」を割り当て、順次実行していくスケジューリングアルゴリズムである^{[1][5][6][18]}。時間スライスが終了すると、次のタスクにリソースが移り、全てのタスクが一巡するまでこのプロセスが繰り返される。RRは、タスクが実行時間を超過することを防ぎ、全てのタスクが公平にリソースを利用できるようにする。

フェアネスと効率のバランス

RRの最大の利点は、全てのタスクに対して公平なリソース割り当てを保証する点である^{[1][5][6][18]}。これは、インタラクティブシステムやマルチユーザー環境で特に有用である。しかし、時間スライスの長さが適切でない場合、システムの効率が低下する可能性がある。時間スライスが短すぎると、コンテキストスイッチが頻繁に発生し、オーバーヘッドが増大する。一方、時間スライスが長すぎると、システムの応答性が低下する。したがって、RRでは、フェアネスと効率のバランスを取るために、時間スライスの適切な設定が重要である。

優先度スケジューリング（Priority Scheduling）

優先度スケジューリング（英: Priority Scheduling）は、各タスクに優先度を設定し、優先度の高いタスクを先に実行するスケジューリングアルゴリズムである^{[1][5][6][18]}。優先度は、システムの要件やタスクの重要性に応じて手動で設定されるか、動的に調整される。

タスクの優先度設定とその影響

優先度スケジューリングの最大の特徴は、重要なタスクが遅延することなく迅速に処理される点である^{[1][5][6][18]}。しかし、優先度が低いタスクが長時間実行されずに放置されるリスクがある。この現象を「優先度逆転」または「スタベーション」と呼ぶ。これを防ぐために、優先度スケジューリングでは、一定時間経過後に優先度を動的に調整する「エイジング」技術が使用されることがある。これにより、低優先度のタスクが一定時間待機した後に優先度が上がり、最終的に実行されるようになる。

優先度スケジューリングは、リアルタイムシステムやミッションクリティカルな環境で広く使用されており、システムの重要なタスクを確実に実行するために不可欠な手法である^{[13][59][60][61]}。しかし、適切な優先度の設定や管理が必要であり、誤った設定はシステム全体のパフォーマンスに悪影響を及ぼす可能性がある。

プログラミング言語におけるSchedulerの実装

プログラミング言語におけるSchedulerの実装は、言語の特性や使用されるプログラミングパラダイムに応じて多様である。Python^[17][20]、JavaScript^[46][52]、Java^[23][62]といった主要な言語やその他の言語には、それぞれ異なるSchedulerの仕組みが存在し、非同期処理やリアクティブプログラミングに対応している。これらのSchedulerの実装により、開発者は効率的にタスクを管理し、システム全体のパフォーマンスと応答性を向上させることができる。

C言語のScheduler

C言語のSchedulerの実装は、シンプルながら強力な機能を提供する^[63][64]。特に、低レベルのシステムプログラミングやリアルタイムシステムにおいて、時間制御やマルチスレッド処理を行うために、setitimer関数やPOSIXスレッドライブラリが利用される。これにより、開発者はタスクの実行タイミングやスケジューリングを精密に制御することができる。

タイマーシグナルとsetitimer関数によるスケジューリング

C言語においては、タイマーシグナルとsetitimer関数を用いたスケジューリングが可能である^[65][66]。setitimer関数は、指定した時間間隔でシグナルを送信するタイマーを設定するために使用される。このシグナルを受け取ると、対応するシグナルハンドラが実行され、これにより特定の処理が定期的に実行されるようにスケジューリングすることができる。SIGALRMシグナルを利用することで、アプリケーション内で周期的なタスクを実行する仕組みを簡単に実装することができる。

POSIXスレッドライブラリによるスレッドスケジューリング

C言語では、POSIXスレッド（Pthreads）ライブラリを用いることで、マルチスレッドプログラミングが可能である^[2][67]。このライブラリは、スレッドの作成、管理、およびスケジューリングのための一連の関数を提供している。スレッドの優先度やスケジューリングポリシーを設定することで、各スレッドの実行順序やタイミングを制御することができる。特にリアルタイムシステムでは、スレッドスケジューリングの詳細な制御が重要であり、POSIXスレッドライブラリはそのための柔軟な手段を提供している。

FortranのScheduler

FortranのSchedulerは、科学計算や数値解析で長い歴史をもつ言語の中で、効率的なタスク管理を行うための機能を提供している^[68][69]。Fortranは、特に計算量の多い処理を得意とし、大規模な数値シミュレーションやデータ処理において広く使用されている。

DOループとタイミング制御によるスケジューリング

Fortranでは、基本的なスケジューリング手法として、DOループを使用したタイミング制御がある^[69][70]。DOループは、指定した回数だけ繰り返し処理を行う構造で、ループの中にタイミング制御を組み込むことで、特定の時間間隔で処理を実行することが可能である。この手法はシンプルであるが、Fortranの高速な実行性能と相まって、効率的な処理を実現する。

並列処理拡張（OpenMP）によるタスク管理

Fortranには、並列処理をサポートするための拡張機能としてOpenMPが存在する^[71][72]。OpenMPは、マルチスレッド並列処理を簡単に実装できるAPIであり、特にFortranで使用されるDOループと相性がいい。OpenMPの指示をループ構造に追加するだけで、複数のプロセッサやコアで並行して処理を実行することが可能となり、大規模な数値計算やデータ処理を効率化する。これにより、Fortranは現代のマルチコアプロセッサを活用して、高速な並列計算を実現する。

LispのScheduler

LispのSchedulerは、動的で柔軟なプログラミング環境において、タスクの管理やスケジューリングを行うための独自の手法を提供している。Lispは、マクロや関数型プログラミングの特性を活かした柔軟な構造をもち、特にAI（人工知能）^[73][74]や言語処理分野^[75][76]での利用が多い。

マクロを用いたカスタムスケジューリング

Lispでは、マクロを利用することで、カスタムスケジューリング機能を実装することができる^[77][78]。マクロは、コードの変換や生成を行うメタプログラミングの手法であり、これにより複雑なスケジューリングロジックを簡潔に表現することが可能である。Lispのマクロシステムは非常に強力であり、タスクの優先順位や条件付き実行などのカスタムスケジューリングを容易に実装できる。

Common Lispでのマルチスレッドサポート

Common Lispでは、マルチスレッドサポートが標準で提供されており、並行処理やタスクのスケジューリングが可能である^[76][79]。Common Lispのスレッド管理は、マルチスレッド環境でのタスク実行を効率的に行うための機能を提供しており、複数のスレッドを用いた並行処理を簡単に実装できる。これにより、Lispプログラムは、複数のタスクを同時に処理し、リソースの利用効率を高めることができる。

COBOLのScheduler

COBOLのSchedulerは、伝統的なビジネスアプリケーションにおいて、タスクの実行順序やタイミングを制御するための手法を提供している^[80][81]。COBOLは、ビジネスデータ処理に特化したプログラミング言語であり、特に大規模な企業システムでの利用が一般的である。

バッチ処理とジョブ制御言語（JCL）によるスケジューリング

COBOLは、バッチ処理システムで広く使用されており、そのスケジューリングはジョブ制御言語（英: Job Control Language、JCL）を使用して行われる^[82][83]。JCLは、バッチジョブを定義し、その実行順序やリソースの割り当てを制御するためのスクリプト言語である。COBOLプログラムは、JCLスクリプト内で実行されることが多く、これにより業務処理のスケジュールが精密に管理される。JCLは、特定の条件下での実行やエラーハンドリングもサポートしており、ビジネスシステムの運用において重要な役割を果たしている。

最新COBOLのスレッド対応と並列処理

最新のCOBOL標準では、スレッド対応が強化されており、並列処理やマルチタスクのスケジューリングが可能である^[82][83]。これにより、COBOLは従来のバッチ処理だけでなく、リアルタイム性が求められるシステムやマルチユーザー環境でも効果的に利用できるようになっている。並列処理機能を活用することで、COBOLプログラムは複数のタスクを同時に処理し、全体のパフォーマンスを向上させることができる。これにより、COBOLは、従来のシステムとの互換性を保ちつつ、現代のコンピューティング環境にも対応している。

C++のScheduler

C++のSchedulerは、標準ライブラリを通じて多様な非同期処理をサポートする^[84][85]。std::threadやstd::asyncを利用することで、マルチスレッド環境での効率的なタスクスケジューリングが可能である。さらに、C++20で導入されたコルーチンにより、非同期処理の柔軟性と効率が大幅に向上している^[86][87]。これにより、複雑な並列処理をシンプルかつ直感的に実装できるようになった。

標準ライブラリの「std::thread」と「std::async」による非同期処理

C++では、標準ライブラリでstd::threadとstd::asyncが提供されており、これらを用いることで非同期処理を簡潔に実装できる^[84][85]。std::threadは、独立したスレッドで関数やコードブロックを実行するためのクラスである。スレッドは生成された時点で自動的にスケジューリングされ、CPUリソースを共有する形で並列に実行される。std::asyncは、非同期タスクの実行をスケジュールするための関数で、将来の結果をstd::futureオブジェクトを通じて取得することができる。これにより、複数のタスクを並列に実行し、その結果を後で処理することが可能である。

C++20で導入されたコルーチンと「std::future」による非同期タスクのスケジューリング

C++20では、新たにコルーチンが導入された^[86][87]。コルーチンは、関数の途中で一時停止し、後で再開できる機能をもつ特殊な関数である。これにより、非同期タスクをより効率的にスケジュールし、管理することが可能となった。コルーチンとstd::futureを組み合わせることで、非同期処理の結果を扱いやすくなり、コードの可読性と保守性が向上する。特に、大規模な並列処理やリアルタイムシステムにおいて、この機能は重要な役割を果たす。

PascalのScheduler

PascalのSchedulerは、教育用途から始まり、様々な応用分野で活用されてきたPascalにおいて、シンプルかつ効果的なタスク管理とタイミング制御を行うための手法を提供している^[88]。Pascalは、プログラミング教育やソフトウェア開発の入門言語として広く知られている。

Timerユニットを使ったタイミング処理

Pascalでは、Timerユニットを使用することで、簡単なタイミング処理を実現することができる^[88]。このユニットは、指定された時間間隔で処理を実行するための機能を提供しており、特定のイベントやタスクを定期的に実行するために利用される。

マルチタスクOS上でのプロセス管理

Pascalは、単純なスケジューリング処理だけでなく、マルチタスクOS上でのプロセス管理にも対応している^[89][90]。特に、Pascalの後期バージョンやDelphiなどの派生言語では、マルチタスクOSの機能を利用して、複数のプロセスを管理し、スケジューリングすることが可能である。これにより、Pascalは複数のタスクを並行して処理し、リソースの効率的な利用やリアルタイム性の要求に応えることができる。これらの機能は、より複雑なアプリケーションやシステムプログラミングでの使用に適している。

AdaのScheduler

AdaのSchedulerは、信頼性が求められるシステムでの厳密な並行処理とスケジューリングを実現するための高度な機能を提供している^[2][91]。Adaは、特にリアルタイムシステムやミッションクリティカルなアプリケーションで使用されることが多いプログラミング言語である。

タスクとプロテクトオブジェクトによる並行処理

Adaにおける並行処理は、言語レベルでのタスク（並行処理単位）のサポートによって実現されている^[91][92]。タスクは、独立して実行されるプロセスやスレッドのようなものであり、Adaのプログラム内で並行して動作する。タスク間の同期や競合状態を防ぐために、プロテクトオブジェクトという機構が提供されており、これによりスレッドセーフな共有資源の管理が可能となる。これらの機能は、リアルタイムシステムでの確実で安全な並行処理を支えるために不可欠である。

リアルタイムシステム向けのスケジューリング機能

Adaは、リアルタイムシステムに特化したスケジューリング機能も備えている^[2][91]。Adaのスケジューリングモデルは、リアルタイムシステムで求められる厳格なタイミング要求に応えるために設計されており、優先度ベースのタスクスケジューリングをサポートしている。これにより、時間制約のあるタスクが確実に指定されたタイミングで実行されることが保証される。また、Adaはタイミング制御やデッドラインの管理を行うための機能も提供しており、リアルタイムシステムにおける信頼性の高い動作を実現している。このため、Adaは航空宇宙^[93]や軍事^[94]、医療システム^[95]など、ミッションクリティカルな分野で広く採用されている。

JavaのScheduler

Javaでは、並行処理やスケジューリングを管理するためにExecutorServiceが提供されている^[23][62]。ExecutorServiceは、スレッドプールを管理し、非同期タスクの実行を効率的にスケジューリングするための柔軟なフレームワークを提供する。

ExecutorServiceの利用

ExecutorServiceは、タスクの並行実行を管理するための高レベルなAPIを提供しており、シングルスレッドからマルチスレッドまで、様々なスレッドプールを簡単に作成できる^[23][62]。開発者は、ExecutorServiceにタスクを送信することで、バックグラウンドでの非同期処理を実現する。例えば、ウェブサーバーで複数のクライアントリクエストを同時に処理する場合、ExecutorServiceが各リクエストを別々のスレッドで並行処理し、システムのスループットを向上させる。

Reactive Streams APIとの連携

Javaのリアクティブプログラミングをサポートするために、Reactive Streams APIが提供されている^[96]。このAPIは、非同期データストリームの処理を可能にし、背圧（バックプレッシャー）メカニズムを備えている。Reactive Streamsは、Publisher、Subscriber、Subscription、Processorの四つのインターフェースを通じて、データの流れを管理し、リアクティブシステムの効率を最適化する。

Schedulerは、このAPIを利用してデータストリームを適切にスケジューリングし、システムがデータの過剰な流れに圧倒されないようにする^[96]。また、Schedulerは、非同期タスクの実行タイミングを調整し、システム全体の応答性を確保する。例えば、Spring WebFluxなどのリアクティブフレームワークでは、Reactive Streams APIとSchedulerを組み合わせることで、高性能でスケーラブルなリアクティブアプリケーションの開発が可能となる^[97]。

PerlのScheduler

PerlのSchedulerは、テキスト処理やスクリプト言語として広く利用されるPerlにおいて、非同期処理やタスク管理を効率的に行うための機能を提供している^[98][99]。Perlは、柔軟性と汎用性が高く、特にシステム管理やネットワークプログラミングにおいて多用されている。

スレッドモジュールとスレッド管理

Perlは、スレッドを使用して並行処理を行うことができる^[98][100]。Perlのスレッドは、threadsモジュールを用いて実装され、プログラム内で複数のスレッドを作成し、それぞれが独立してタスクを実行することが可能である。スレッド間のデータ共有は、threads::sharedモジュールを使用して行われ、スレッドのスケジューリングや同期を適切に管理することが求められる。これにより、Perlプログラムはマルチタスクの実行や、複数のタスクを並行して処理するシステムを構築できる。

イベントループと非同期I/O（AnyEventなど）

Perlは、イベントループを用いた非同期I/O処理にも対応している^[98][99]。AnyEventやPOE（Perl Object Environment）といったモジュールは、非同期イベント駆動型のプログラミングをサポートし、複数のI/O処理を同時に効率よく処理することができる。これにより、ネットワークサーバーやリアルタイムアプリケーションの開発が容易になる。AnyEventは、様々なバックエンド（EV、IO::Asyncなど）を抽象化して統一的に扱えるインターフェースを提供しており、プログラムはバックエンドに依存しない形でイベント駆動型の処理を記述できる。これにより、Perlはシングルスレッドでも高い並行処理性能を発揮し、リソース効率のいいタスクスケジューリングを実現する。

PythonのScheduler

Pythonでは、非同期処理を実現するための主要なツールとしてasyncioモジュールが提供されている^[17][101]。このモジュールは、イベントループを利用して非同期タスクを管理し、複数のタスクが効率的に並行処理されるようにスケジューリングする。asyncioモジュールは、シンプルなAPIを提供しており、開発者は非同期タスクを簡単に記述できる。

asyncioモジュールとその使用例

asyncioモジュールは、Pythonにおける非同期処理の中心的なツールであり、コルーチンを用いて非同期タスクを定義する^[17][20]。例えば、async defによって定義された関数はコルーチンとして扱われ、awaitキーワードを使用して他のコルーチンや非同期タスクを待機することができる。asyncioモジュールのイベントループは、これらのコルーチンをスケジューリングし、I/O処理やタイマーなどのイベントが発生した際に適切にタスクを実行する。

具体的な使用例として、非同期のウェブクローラー^[102]やリアルタイムチャットアプリケーション^[102]などが挙げられる。これらのアプリケーションでは、複数のネットワークリクエストやユーザーからの入力を同時に処理する必要があり、asyncioのSchedulerが効率的にタスクを管理している。

リアクティブプログラミングライブラリ（RxPyなど）

Pythonには、リアクティブプログラミングを実現するためのライブラリとして、RxPy（Reactive Extensions for Python）がある^[103]。RxPyは、データストリームの変化にリアクティブ（敏感）に反応するプログラミングモデルを提供しており、オブザーバブルとオブザーバーを用いたパターンを実現する。RxPyでは、Schedulerがデータストリームを監視し、必要なタイミングでオブザーバーに通知を行う。

RxPyを用いることで、複数の非同期イベントを簡潔に管理し、リアクティブ（敏感）なデータ処理を実装することが可能である^[103]。例えば、リアルタイムデータのフィルタリングやイベント駆動型のユーザーインターフェースの構築において、RxPyのSchedulerが活躍する。

JavaScriptのScheduler

JavaScriptでは、非同期処理を効率的に管理するためのイベントループが組み込まれており、これがSchedulerの役割を果たしている^[45][46]。JavaScriptの非同期処理は、主にプロミス（Promise）^{[注釈 1]}とasync/await構文を用いて実現されている^[21][45]。

イベントループとプロミスのスケジューリング

JavaScriptのイベントループは、タスクキューを監視し、実行可能なタスクを順次処理していく^[45][46]。このプロセスで、プロミスが解決されたり、非同期関数が完了したりする度に、対応するコールバックがスケジューリングされる。イベントループは、タスクを逐次処理するシングルスレッドで動作するが、非同期処理を効率的に管理することで、アプリケーションが応答性を維持しながら複数のタスクを同時に処理することが可能である。

非同期関数とawaitのメカニズム

非同期関数は、asyncキーワードを使って定義され、内部でawaitキーワードを使用することで、非同期処理の完了を待つことができる^[21][45]。awaitは、プロミスの解決を待ち、それが完了したら次のコードを実行する。これにより、非同期処理が同期的に記述できるようになり、コードの可読性が向上する。Schedulerは、awaitによって中断された非同期関数を適切なタイミングで再開し、イベントループ内でタスクをスムーズに管理する。

RubyのScheduler

RubyのSchedulerは、シンプルかつ柔軟な非同期タスク管理の手法を提供している^[105][106]。Rubyはインタプリタ言語でありながら、効率的な非同期処理を実現するための機能が豊富に揃っている。

Fiberとスレッドによる非同期タスクの管理

Rubyでは、軽量な並行処理を実現するためにFiberとスレッドを活用できる^[107][108]。Fiberは、協調的なマルチタスクを実現するための機能で、スレッドに比べて非常に軽量である。複数のFiberを使ってタスクを切り替えながら実行することで、効率的な非同期処理が可能となる。一方、RubyのスレッドはOSのスレッドをラップしており、真の並行処理を実現できるが、グローバルインタプリタロック（GIL）の影響を受けるため、CPUバウンド（CPUの処理能力がボトルネックとなる状態）なタスクには限界がある。

EventMachineライブラリによるイベント駆動型プログラミング

EventMachineは、Rubyでイベント駆動型プログラミングを行うための強力なライブラリである^[105][109]。このライブラリを使用することで、ネットワークアプリケーションやリアルタイム処理など、非同期なイベントを効率的に管理することができる。EventMachineは、単一スレッド内で多くのクライアント接続を同時に処理するためのイベントループを提供しており、リソースの消費を最小限に抑えつつ、スケーラブルなアプリケーションを構築するのに適している。

GoのScheduler

GoのSchedulerは、シンプルでありながら強力な並行処理の機能を備えている^[4][110]。Goは並行処理を容易に行うための機構として、ゴルーチンとチャネルを提供している。

ゴルーチンとチャネルを用いた並行処理

Goのゴルーチンは、非常に軽量なスレッドのようなものであり、大量のゴルーチンを並行して実行することが可能である^[4][110]。これにより、効率的な並行処理が実現される。ゴルーチンは、シンプルなgoキーワードを用いて開始でき、プログラム内で独立した処理を並行して実行するのに適している。チャネルは、ゴルーチン間でデータをやり取りするための同期手段であり、これを用いることで、ゴルーチン間の通信と同期を容易に行うことができる。

Goランタイムによるマルチスレッドスケジューリング

Goランタイムは、ゴルーチンを自動的にマルチスレッドでスケジュールするための機能をもっている^[4][110]。これにより、プログラマーは低レベルのスレッド管理に煩わされることなく、ゴルーチンを活用した並行処理を行うことができる。Goランタイムは、スレッドの数を最適化し、ゴルーチンを効率的にスケジューリングすることで、パフォーマンスを最大化するよう設計されている。

RustのScheduler

RustのSchedulerは、安全かつ効率的な非同期プログラミングをサポートするための強力なツールを提供している^[111][112]。Rustは、メモリ安全性と高性能を両立させるプログラミング言語として知られており、非同期処理の分野でもその強みを発揮している。

Tokioクレートによる非同期プログラミング

Rustにおいて、非同期プログラミングを行う際に最も一般的に使用されるのがTokioクレートである^[112][113]。Tokioは、非同期I/Oやタスクのスケジューリングをサポートするライブラリであり、高性能なサーバーやリアルタイムアプリケーションの開発に適している。Tokioは、シングルスレッドでもマルチスレッドでも動作するため、スケーラブルな非同期処理を効率的に実装することができる。

async/awaitとFutureトレイトによる非同期タスクのスケジューリング

Rustのasync/await構文とFutureトレイトは、非同期処理を直感的に記述するための手段である^[111][112]。これにより、非同期タスクの実行を簡単にスケジュールし、その結果を扱うことができる。Rustの型システムと所有権モデルは、非同期処理におけるデータ競合やメモリリークを防ぎ、安全な並行プログラミングを実現する。これにより、複雑な非同期処理を行う際にも、信頼性と性能を両立させたプログラムを書くことが可能である。

PHPのScheduler

PHPのSchedulerは、主にWeb開発で広く利用されるPHPにおいて、効率的なタスク管理と非同期処理を実現するための機能を提供している^[114][115]。PHPは、サーバーサイドスクリプト言語としての役割が中心でありながら、非同期処理やイベント駆動型のプログラミングにも対応できる柔軟な機能をもっている。

タイマー関数によるスケジューリング

PHPでは、sleepやusleep、set_time_limitなどのタイマー関数を用いることで、簡単なスケジューリングを実装することができる^[114][115]。これらの関数を使用して、指定した時間間隔でタスクを実行する仕組みを構築できる。例えば、sleep関数を利用して一定時間待機した後に処理を続行することで、周期的なタスクの実行や、一定の遅延を伴う処理を行うことができる。ただし、これらの関数は同期的に動作するため、スクリプト全体が待機状態になる点には注意が必要である。

イベント駆動型フレームワーク（ReactPHPなど）

PHPでは、より高度なスケジューリングや非同期処理を行うために、ReactPHPなどのイベント駆動型フレームワークが利用される^[115][116]。ReactPHPは、非同期I/O処理をサポートし、イベントループを使用してタスクを効率的に管理するためのライブラリである。これにより、リアルタイムアプリケーションやチャットサーバー、WebSocketサーバーなど、同時に多数の接続を扱う必要があるアプリケーションの開発が可能になる。ReactPHPは、PromiseベースのAPIを提供しており、非同期処理をシンプルかつ直感的に記述することができる。これにより、PHPでありながら、シングルスレッド環境でも高い並行処理性能を発揮し、効率的なタスクスケジューリングを実現する。

SwiftのScheduler

SwiftのSchedulerは、Appleのエコシステムで効率的な並行処理を実現するための機能を提供している^[117][118]。Swiftは、iOSやmacOS向けのアプリケーション開発において、高いパフォーマンスと柔軟性をもつ非同期処理の実装が可能である。

Grand Central Dispatch（GCD）とOperationQueueによるスケジューリング

Swiftにおいて、Grand Central Dispatch（GCD）は並行処理を効率的に行うための基盤技術である^[118][119]。GCDを使用することで、スレッドの管理を開発者が意識することなく、タスクをバックグラウンドで非同期に実行することができる。タスクはキューに投入され、システムによって適切にスケジューリングされるため、リソースの最適な利用が可能である。OperationQueueは、GCDをさらに抽象化したもので、依存関係のあるタスクの管理や、並行度の制御をより簡単に行えるようにしている。これにより、複雑な並行処理を直感的に扱うことができる。

Combineフレームワークによるリアクティブプログラミング

SwiftのCombineフレームワークは、リアクティブプログラミングを実現するための強力なツールである^[118][120]。Combineは、非同期イベントのストリームを処理し、データの変化に応じてリアクティブ（敏感）に処理を行うことができる。PublisherとSubscriberという概念を中心に構築されており、これによりデータの流れを柔軟に処理し、非同期処理をスケジュールすることができる。Combineは、Swiftのasync/await構文とも統合されており、モダンな非同期プログラミングをシンプルに実装できるように設計されている。

KotlinのScheduler

KotlinのSchedulerは、Android開発やサーバーサイドプログラミングで広く使用されており、非同期処理の柔軟な制御を可能にしている^[121][122]。Kotlinは、Javaとの互換性を保ちながらも、よりモダンで効率的なプログラミングスタイルを提供する。

コルーチンによる非同期処理

Kotlinのコルーチンは、非同期処理をシンプルかつ効率的に実装するための機能である^[121][123]。コルーチンは、スレッドよりも軽量であり、大量の並行タスクを効率的に処理することができる。suspend関数を用いて非同期処理を中断・再開でき、開発者は非同期コードを同期コードのように記述することが可能である。これにより、非同期処理の複雑さが大幅に軽減され、コードの可読性が向上する。

コルーチンディスパッチャによるスケジューリング制御

Kotlinのコルーチンディスパッチャ（Coroutine Dispatcher）は、コルーチンの実行環境を指定するための機能である^[121][122]。ディスパッチャを使用することで、どのスレッドまたはスレッドプールでコルーチンが実行されるかを制御することができる。例えば、Dispatchers.IOはI/O処理に特化したスレッドプールで実行され、Dispatchers.Mainはメインスレッド（ユーザーインターフェーススレッド）で実行される。これにより、開発者はタスクの種類に応じて適切なスケジューリングを設定し、アプリケーションのパフォーマンスを最適化できる。コルーチンとディスパッチャの組み合わせにより、Kotlinでは高度な並行処理が直感的に行えるようになっている。

ScalaのScheduler

ScalaのSchedulerは、関数型プログラミングとオブジェクト指向プログラミングを融合させた言語の特性を活かし、柔軟で強力な非同期処理と並行処理の機能を提供している^[124][125]。Scalaは、特にビッグデータ処理や並行分散システムで多く採用されている^[124][126]。

FutureとPromiseによる非同期処理

Scalaでは、FutureとPromiseを使用して非同期処理を簡潔に実装することができる^[124][125]。Futureは、非同期に実行される計算の結果を表現し^{[注釈 1]}、その結果が利用可能になった時点で続行処理を行うための構造である。一方、Promiseは、後でその結果を設定することができるFutureの一種で、プログラマーはPromiseを用いて結果を非同期に設定し、Futureとしてその結果を取得することができる。これにより、非同期処理のフローを自然な形で記述できる。

Akkaフレームワークによるアクターモデルのスケジューリング

Scalaでは、並行処理を効率的に行うためにAkkaフレームワークが広く使われている^[54][127]。Akkaはアクターモデルをベースにしたフレームワークであり、アクター同士がメッセージをパッシングすることで並行処理を実現する。アクターモデルは、スレッドセーフな方法で状態をもつオブジェクトを管理できるため、高いスケーラビリティと高い信頼性を求められるシステムに適している。Akkaフレームワークでは、アクターが自動的にスケジューリングされ、効率的に並行処理が行われる。これにより、Scalaでの大規模な分散システムやリアクティブシステムの構築が可能になる。

HaskellのScheduler

HaskellのSchedulerは、純粋関数型プログラミング言語であるHaskellの特性を活かし、安全かつ効率的な並行処理と非同期処理の管理を提供している^[128][129]。Haskellは、強力な型システムと遅延評価を特徴とする言語であり、並行処理においても独自のアプローチを採用している。

ソフトウェアトランザクショナルメモリ（STM）によるスケジューリング

Haskellでは、並行処理のためにソフトウェアトランザクショナルメモリ（Software Transactional Memory、STM）がサポートされている^[128][129]。STMは、トランザクションの概念を用いて、複数のスレッド間でのメモリ共有を安全に行うための仕組みである。STMを使用することで、デッドロックや競合状態を回避しつつ、複雑な並行処理をシンプルに記述することが可能である。これにより、Haskellでの並行処理は安全かつ効率的にスケジュールされる。

asyncライブラリと非同期処理の管理

Haskellでは、非同期処理を行うためにasyncライブラリが提供されている^[128][129]。asyncライブラリは、非同期タスクの実行とその結果の管理をシンプルに行うためのAPIを提供しており、開発者は直感的に非同期処理を記述することができる。asyncを用いることで、非同期タスクの競合状態を避けつつ、複数のタスクを並行して実行し、その結果を効率的に集約することができる。これにより、Haskellの非同期処理は強力かつエレガントに管理される。

ElixirのScheduler

ElixirのSchedulerは、並行処理に特化したErlang VM（BEAM）上で動作するElixirの特性を活かし、高いスケーラビリティと信頼性をもつスケジューリング機能を提供している^[130][131]。Elixirは、シンプルで直感的な文法と強力な並行処理モデルを組み合わせた言語であり、特にリアルタイムシステムや分散システムで利用されている。

プロセスとメッセージパッシングによる並行処理

Elixirでは、Erlangのプロセスモデルを利用して並行処理を実現している^[130][131]。Elixirのプロセスは軽量であり、数百万単位のプロセスを同時に生成し、メッセージパッシングを用いてプロセス間の通信を行うことができる。このモデルにより、Elixirは並行処理をシンプルに実装しつつ、高いスケーラビリティとフォールトトレランスを実現している。プロセス間のメッセージパッシングは非同期で行われ、これによりタスクのスケジューリングが効率的に管理される。

OTP（Open Telecom Platform）によるスケジューリング制御

Elixirは、OTP（Open Telecom Platform）フレームワークを通じて、さらに強力なスケジューリングと並行処理の管理を行っている^[130][132]。OTPは、分散システムやリアルタイムアプリケーションの構築に必要な一連のライブラリとツールを提供しており、Elixirでの開発を大幅に支援する。OTPの主要コンポーネントであるGenServerやSupervision Treeは、タスクのスケジューリングやプロセスの監視を容易にし、システムの信頼性と可用性を高める。これにより、Elixirでのスケジューリング制御は柔軟かつ強力なものとなっている。

F#のScheduler

F#のSchedulerは、関数型プログラミングをベースとした言語特性を活かし、効率的な非同期処理とタスクスケジューリングを実現するための機能を提供している^[133][134]。F#は、.NET Framework上で動作し、幅広いアプリケーション開発に対応している。

Asyncワークフローによる非同期処理

F#では、Asyncワークフローを使用して非同期処理を簡潔に実装することができる^[133][134]。Asyncワークフローは、非同期タスクをシンプルな構文で記述し、それを同期コードのように扱うことができる。これにより、複雑な非同期処理も見通しのよいコードで実装できる。Asyncワークフローは、バックグラウンドでの処理やI/O処理、並列計算などに適しており、F#の強力な型システムと組み合わせて安全かつ効率的に非同期タスクをスケジュールすることが可能である。

タスク並列ライブラリ（TPL）との連携

F#は、.NET Frameworkのタスク並列ライブラリ（英: Task Parallel Library、TPL）と密接に連携している^[134][135]。TPLは、マルチスレッド処理や並列タスクの管理を効率的に行うためのライブラリであり、F#からも利用可能である。これにより、F#のプログラムは高度な並列処理やマルチコアプロセッサを活用したタスクスケジューリングを行うことができる。TPLとの連携により、F#でのスケジューリングは、柔軟性とパフォーマンスを両立した形で実現されている。

Schedulerの応用分野

Schedulerは、多様な分野で広く応用されており、特にリアルタイムシステム、データベーストランザクション、分散システムやクラウドコンピューティングにおいて、その重要性が際立っている。これらの応用分野では、タスクやプロセスの実行順序を適切に管理し、システムの効率や信頼性を最大化するためにSchedulerが利用されている。

リアルタイムシステム

リアルタイムシステムは、タスクの実行が厳密なタイミング制約をもつシステムであり、例えば、航空機の制御システム^[136]や医療機器^[41]、自動車の制御システム^[42]など、ミッションクリティカルなアプリケーションで使用される。これらのシステムでは、タスクが特定のデッドライン内に完了することが求められるため、Schedulerはタスクの優先度や緊急性に基づいて厳密にスケジューリングを行う。

リアルタイムスケジューラ（Real-Time Scheduler）は、システム全体のリアルタイム性を保証するために設計されており、タスクが遅延することなく実行されるように調整される^[13][60]。固定優先度スケジューリング（英: Fixed-Priority Scheduling）や最早期限優先（英: Earliest Deadline First、EDF）などのアルゴリズムがリアルタイムシステムで使用され、システムが要求される応答性を維持できるようにする。

データベーストランザクション

データベーストランザクションにおいてもSchedulerは重要な役割を果たす^{[137][138][139][140]}。トランザクションは、データベースに対する一連の処理が完全に成功するか、全く行われないかを保証するものであり、Schedulerはこれらのトランザクションを適切にスケジューリングしてリソースの競合を管理する。

データベース管理システム（DBMS）では、複数のトランザクションが同時に実行されることが一般的であり、Schedulerは、これらのトランザクションが相互に干渉しないようにスケジューリングを行う^{[137][138][139][140]}。また、トランザクションの優先度や整合性制約に基づいて実行順序を決定し、データベースの整合性と一貫性を維持する。Schedulerが適切に機能することで、データベースシステムは高いスループットと応答性を実現しつつ、データの整合性を保つことができる。

分散システムとクラウドコンピューティング

分散システム^[16][141]やクラウドコンピューティング環境^[142][143]では、複数のコンピュータやサーバーが協力してタスクを実行するため、Schedulerはシステム全体のリソースを効率的に管理するために不可欠である。これらの環境では、タスクが複数のノード間で分散され、Schedulerは各ノードの負荷を考慮してタスクを最適に割り当てる。

クラウドコンピューティングでは、ユーザーからの要求が多様であり、システムは動的にスケーリングされる^[142][144]。Schedulerは、リソースの自動割り当てと調整を行い、システムのパフォーマンスを最適化する。例えば、Apache Hadoop^[145]やApache Spark^[146]などの分散処理フレームワークでは、Schedulerがタスクをクラスタ内の複数のノードに効率的に割り当てることで、大規模なデータ処理が迅速に行われる。

また、クラウドベースのサービスでは、オンデマンドでリソースが提供されるため、Schedulerは利用可能なリソースを動的に管理し、リソースの過剰な利用や不足を防ぐ役割も担う^[142][147]。これにより、クラウドコンピューティング環境では高い柔軟性とコスト効率が実現され、ユーザーの要求に応じたリソースの最適化が行われる。

総じて、Schedulerはリアルタイムシステムからクラウドコンピューティングに至るまで、多岐に渡る応用分野で不可欠な要素であり、システムの効率性、応答性、信頼性を支える中核的な技術として機能している。

パフォーマンスと最適化

Schedulerのパフォーマンスと最適化は、システム全体の効率と応答性に直接影響を与えるため、非常に重要である^[29][148]。特に、高負荷のシステムやリアルタイム性が求められる環境では、Schedulerの適切な調整がシステムのパフォーマンスを大きく左右する。Schedulerのオーバーヘッドを最小限に抑え、パフォーマンスを最適化するためには、様々な技術や手法が必要となる。

スケジューリングのオーバーヘッド

スケジューリングのオーバーヘッドとは、Schedulerがタスクを管理・切り替えする際に発生する計算リソースの消費を指す^[5][11]。オーバーヘッドは、タスクのコンテキストスイッチ、スケジューリングアルゴリズムの実行、リソースの割り当てなどで発生する。このオーバーヘッドが増大すると、システムの全体的なパフォーマンスが低下するため、Schedulerは効率的に動作することが求められる。

コンテキストスイッチは、実行中のタスクが中断され、別のタスクが開始される際に、現在のタスクの状態を保存し、新しいタスクの状態をロードするプロセスである^{[1][5][6][11]}。このスイッチは必要不可欠だが、頻繁に発生するとオーバーヘッドが増加し、システムのスループットが低下する。オーバーヘッドを最小限に抑えるためには、コンテキストスイッチの回数を適切に管理することが重要である。

さらに、スケジューリングアルゴリズム自体もオーバーヘッドの一因となる^{[1][30][149][150]}。例えば、優先度スケジューリング（英: Priority Scheduling）では、タスクの優先度を評価し、最適なタスクを選択するために追加の計算が必要となる。これにより、スケジューリングプロセスが複雑化し、オーバーヘッドが増加する可能性がある。したがって、スケジューリングアルゴリズムの選択と最適化は、オーバーヘッドを抑制するための重要な要素となる。

パフォーマンスチューニングとベンチマーク

Schedulerのパフォーマンスチューニングは、システムの特性や要件に応じて最適な動作を実現するためのプロセスである^{[29][148][151][152]}。チューニングでは、Schedulerの設定やスケジューリングアルゴリズムのパラメータを調整し、システムの効率を最大化することを目指す。例えば、ラウンドロビンスケジューリング（Round-Robin Scheduling、RR）では、時間スライスの長さを調整することで、コンテキストスイッチの頻度とシステムの応答性のバランスを最適化できる。

パフォーマンスチューニングの効果を評価するためには、ベンチマークが不可欠である^{[29][148][153][154]}。ベンチマークは、特定の条件下でシステムのパフォーマンスを測定し、チューニングの効果を定量的に評価するためのテストである。Schedulerのベンチマークでは、タスクの処理時間、コンテキストスイッチの頻度、システムのスループット、レスポンスタイムなどの指標が測定される。

ベンチマークの結果を分析することで、Schedulerのパフォーマンスを改善するための具体的なアプローチが見えてくる^{[29][148][153][155]}。例えば、オーバーヘッドが高い場合は、アルゴリズムをよりシンプルなものに変更したり、タスクの優先度を再調整するなどの対策が考えられる。これにより、システムは限られたリソースを最大限に活用し、効率的に動作することが可能となる。

また、実際の運用環境でSchedulerのパフォーマンスを監視し、動的に調整を行うことも重要である^[29][156]。これにより、システムの負荷変動に柔軟に対応し、常に最適なパフォーマンスを維持することができる。

総じて、Schedulerのパフォーマンスチューニングとベンチマークは、システムの安定性と効率性を確保するための不可欠なプロセスである。

脚注

[脚注の使い方]

注釈

1. ^ ^{a b} プロミスとフューチャーはデザインパターンではない^{[17][23][52][104]}。以下は書籍『You Don't Know JS: ES6 & Beyond』で述べられている、デザインパターンではないという説明の引用である。

   "Promises and Futures are not design patterns, but rather fundamental constructs that aid in managing asynchronous code in JavaScript." — Chapter 4: Async Flow Control

出典

1. ^ ^{a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad ae af} Silberschatz, Abraham; Galvin, Peter B.; Gagne, Greg (2018-01-11) (英語). Operating System Concepts, 10e Abridged Print Companion. John Wiley & Sons. ISBN 978-1-119-43925-7. https://www.google.co.jp/books/edition/Operating_System_Concepts_10e_Abridged_P/VFV1DwAAQBAJ?hl=ja&gbpv=1&dq=Operating+System+Concepts&printsec=frontcover 
2. ^ ^{a b c d e f g h i j k l m n} Kopetz, Hermann (2011-04-26) (英語). Real-Time Systems: Design Principles for Distributed Embedded Applications. Springer US. ISBN 978-1-4419-8236-0. https://www.google.co.jp/books/edition/_/cDbNjwEACAAJ?hl=ja&sa=X&ved=2ahUKEwiK5Oq6g-qHAxWha_UHHVveB3cQ7_IDegQIGxAE 
3. ^ ^{a b c d e f g h i j k l m} Nurkiewicz, Tomasz; Christensen, Ben (2016-10-06) (英語). Reactive Programming with RxJava: Creating Asynchronous, Event-Based Applications. "O'Reilly Media, Inc.". ISBN 978-1-4919-3160-8. https://www.google.co.jp/books/edition/Reactive_Programming_with_RxJava/gYY1DQAAQBAJ?hl=ja&gbpv=1&dq=Reactive+Programming+with+RxJava&printsec=frontcover 
4. ^ ^{a b c d e f g} Cox-Buday, Katherine (2017) (英語). Concurrency in Go: Tools & Techniques for Developers. O'Reilly Media, Incorporated. ISBN 978-1-4919-4129-4. https://www.google.co.jp/books/edition/Concurrency_in_Go/qmzqswEACAAJ?hl=ja 
5. ^ ^{a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad ae af ag} Stallings, William (2018) (英語). Operating Systems: Internals and Design Principles. Pearson. ISBN 978-0-13-467095-9. https://www.google.co.jp/books/edition/Operating_Systems/u5M5nQAACAAJ?hl=ja 
6. ^ ^{a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad ae} Tanenbaum, Andrew S.; Bos, Herbert (2015-01-23) (英語). Modern Operating Systems, Global Edition. Pearson Education. ISBN 978-1-292-06195-5. https://www.google.co.jp/books/edition/Modern_Operating_Systems_Global_Edition/FV2pBwAAQBAJ?hl=ja 
7. ^ ^{a b c d e} Hennessy, John L.; Patterson, David A. (2014-05-12) (英語). Computer Organization and Design: The Hardware / Software Interface. Elsevier. ISBN 978-1-4832-2118-2. https://www.google.co.jp/books/edition/_/_eU_CQAAQBAJ?hl=ja&sa=X&ved=2ahUKEwif49S9hOqHAxVciq8BHS3WHj0Q7_IDegQIHBAF 
8. ^ ^{a b} Breshears, Clay (2009-05-07) (英語). The Art of Concurrency: A Thread Monkey's Guide to Writing Parallel Applications. "O'Reilly Media, Inc.". ISBN 978-0-596-55578-8. https://www.google.co.jp/books/edition/The_Art_of_Concurrency/rU68SYVS7S8C?hl=ja&gbpv=1&dq=The+Art+of+Concurrency&printsec=frontcover 
9. ^ ^{a b c d e f} Kerrisk, Michael (2010-10-01) (英語). The Linux Programming Interface: A Linux and UNIX System Programming Handbook. No Starch Press. ISBN 978-1-59327-291-3. https://www.google.co.jp/books/edition/The_Linux_Programming_Interface/Ps2SH727eCIC?hl=ja&gbpv=0 
10. ^ Pllana, Sabri; Xhafa, Fatos (2017-01-23) (英語). Programming Multicore and Many-core Computing Systems. John Wiley & Sons. ISBN 978-1-119-33200-8. https://www.google.co.jp/books/edition/Programming_Multicore_and_Many_core_Comp/NIH5DQAAQBAJ?hl=ja&gbpv=1&dq=Programming+Multicore+and+Many-core+Platforms&printsec=frontcover 
11. ^ ^{a b c d} Arpaci-Dusseau, Remzi H.; Arpaci-Dusseau, Andrea C. (2018) (英語). Operating Systems: Three Easy Pieces. Arpaci-Dusseau Books, LLC. ISBN 978-1-9850-8659-3. https://www.google.co.jp/books/edition/Operating_Systems/0a-ouwEACAAJ?hl=ja 
12. ^ Carver, Richard H.; Tai, Kuo-Chung (2005-11-28) (英語). Modern Multithreading: Implementing, Testing, and Debugging Multithreaded Java and C++/Pthreads/Win32 Programs. John Wiley & Sons. ISBN 978-0-471-74416-0. https://www.google.co.jp/books/edition/Modern_Multithreading/4dZWn8rnU2cC?hl=ja&gbpv=0 
13. ^ ^{a b c d e f g h i j k l m} Liu, Jane W. S. (2000) (英語). Real-Time Systems. Prentice Hall. ISBN 978-0-13-099651-0. https://www.google.co.jp/books/edition/Real_Time_Systems/855QAAAAMAAJ?hl=ja&gbpv=1&bsq=Real-Time+Systems+Jane+W.+S.+Liu&dq=Real-Time+Systems+Jane+W.+S.+Liu&printsec=frontcover 
14. ^ Noergaard, Tammy (2012-12-31) (英語). Embedded Systems Architecture: A Comprehensive Guide for Engineers and Programmers. Newnes. ISBN 978-0-12-382197-3. https://www.google.co.jp/books/edition/Embedded_Systems_Architecture/96jSXetmlzYC?hl=ja&gbpv=0 
15. ^ Lee, Insup; Leung, Joseph Y.-T.; Son, Sang H. (2007-07-23) (英語). Handbook of Real-Time and Embedded Systems. CRC Press. ISBN 978-1-4200-1174-6. https://www.google.co.jp/books/edition/Handbook_of_Real_Time_and_Embedded_Syste/Bz7DTDZQaGIC?hl=ja&gbpv=1&dq=Handbook+of+Real-Time+and+Embedded+Systems&printsec=frontcover 
16. ^ ^{a b c d} Tanenbaum, Andrew S.; Steen, Maarten van (2007) (英語). Distributed Systems: Principles and Paradigms. Pearson Prentice Hall. ISBN 978-0-13-239227-3. https://www.google.co.jp/books/edition/Distributed_Systems/DL8ZAQAAIAAJ?hl=ja&gbpv=1&bsq=Distributed+Systems:+Principles+and+Paradigms&dq=Distributed+Systems:+Principles+and+Paradigms&printsec=frontcover 
17. ^ ^{a b c d e f g h i} Fowler, Matthew (2022-03-15) (英語). Python Concurrency with asyncio. Simon and Schuster. ISBN 978-1-63835-708-7. https://www.google.co.jp/books/edition/Python_Concurrency_with_asyncio/M9xdEAAAQBAJ?hl=ja&gbpv=1&dq=Python+Concurrency+with+asyncio&printsec=frontcover 
18. ^ ^{a b c d e f g h i} Bryant, Randal E.; O'Hallaron, Davie Richard (2016) (英語). Computer Systems: A Programmer's Perspective. Pearson. ISBN 978-0-13-409266-9. https://www.google.co.jp/books/edition/_/7-IaogEACAAJ?hl=ja&sa=X&ved=2ahUKEwjC_c34iOqHAxXYlFYBHQY9Ns0Q7_IDegQIExAC 
19. ^ ^{a b c d e f} Anderson, Thomas; Dahlin, Michael (2014) (英語). Operating Systems: Principles and Practice. Recursive Books. ISBN 978-0-9856735-2-9. https://www.google.co.jp/books/edition/Operating_Systems/yWc_MQAACAAJ?hl=ja 
20. ^ ^{a b c d e} Slatkin, Brett (2015-02-12) (英語). Effective Python: 59 Specific Ways to Write Better Python. Addison-Wesley Professional. ISBN 978-0-13-403440-9. https://www.google.co.jp/books/edition/Effective_Python/ocmqBgAAQBAJ?hl=ja&gbpv=1&dq=Effective+Python&printsec=frontcover 
21. ^ ^{a b c d e f g h i j} Flanagan, David (2020-05-14) (英語). JavaScript: The Definitive Guide: Master the World's Most-Used Programming Language. "O'Reilly Media, Inc.". ISBN 978-1-4919-5198-9. https://www.google.co.jp/books/edition/JavaScript_The_Definitive_Guide/NPbkDwAAQBAJ?hl=ja&gbpv=1&printsec=frontcover 
22. ^ Stefanov, Stoyan (2010-09-09) (英語). JavaScript Patterns: Build Better Applications with Coding and Design Patterns. "O'Reilly Media, Inc.". ISBN 978-1-4493-9694-7. https://www.google.co.jp/books/edition/JavaScript_Patterns/WTZqecc9olUC?hl=ja&gbpv=1&dq=JavaScript+Patterns&printsec=frontcover 
23. ^ ^{a b c d e} Goetz, Brian (2006) (英語). Java Concurrency in Practice. Addison-Wesley. ISBN 978-0-321-34960-6. https://www.google.co.jp/books/edition/Java_Concurrency_in_Practice/6LpQAAAAMAAJ?hl=ja&gbpv=1&bsq=Java+Concurrency+in+Practice&dq=Java+Concurrency+in+Practice&printsec=frontcover 
24. ^ Silberschatz, Abraham; Korth, Henry F.; Sudarshan, S. (2020) (英語). Database System Concepts. McGraw-Hill Education. ISBN 978-1-260-08450-4. https://www.google.co.jp/books/edition/Database_System_Concepts/5xbQuwEACAAJ?hl=ja 
25. ^ ^{a b} Kleppmann, Martin (2017-03-16) (英語). Designing Data-Intensive Applications: The Big Ideas Behind Reliable, Scalable, and Maintainable Systems. "O'Reilly Media, Inc.". ISBN 978-1-4919-0311-7. https://www.google.co.jp/books/edition/Designing_Data_Intensive_Applications/zFheDgAAQBAJ?hl=ja&gbpv=1&dq=Designing+Data-Intensive+Applications&printsec=frontcover 
26. ^ Quinn, Michael J.; Quinn (1994) (英語). Parallel Computing: Theory and Practice. McGraw-Hill. ISBN 978-0-07-051295-5. https://www.google.co.jp/books/edition/Parallel_Computing/RDraAAAACAAJ?hl=ja 
27. ^ Levesque, John; Wagenbreth, Gene (2010-12-14) (英語). High Performance Computing: Programming and Applications. CRC Press. ISBN 978-1-4200-7706-3. https://www.google.co.jp/books/edition/High_Performance_Computing/orRQcftFRtkC?hl=ja&gbpv=1&dq=High+Performance+Computing:+Programming+and+Applications&printsec=frontcover 
28. ^ Hennessy, John L.; Patterson, David A. (2017-11-23) (英語). Computer Architecture: A Quantitative Approach. Morgan Kaufmann. ISBN 978-0-12-811906-8. https://www.google.co.jp/books/edition/Computer_Architecture/cM8mDwAAQBAJ?hl=ja&gbpv=1&dq=Computer+Architecture:+A+Quantitative+Approach+2017&printsec=frontcover 
29. ^ ^{a b c d e f} Gregg, Brendan (2013-10-07) (英語). Systems Performance: Enterprise and the Cloud. Prentice Hall. ISBN 978-0-13-339010-0. https://www.google.co.jp/books/edition/Systems_Performance/pTYkAQAAQBAJ?hl=ja&gbpv=1&bsq=Systems+Performance:+Enterprise+and+the+Cloud&dq=Systems+Performance:+Enterprise+and+the+Cloud&printsec=frontcover 
30. ^ ^{a b c} McKusick, Marshall Kirk; Neville-Neil, George V.; Watson, Robert N. M. (2014-09-25) (英語). The Design and Implementation of the FreeBSD Operating System. Addison-Wesley Professional. ISBN 978-0-13-376183-2. https://www.google.co.jp/books/edition/The_Design_and_Implementation_of_the_Fre/KfCuBAAAQBAJ?hl=ja&gbpv=1&dq=Design+and+Implementation+of+the+FreeBSD+Operating+System&printsec=frontcover 
31. ^ ^{a b c d e f g} Pillet, Florent; Junior, Bontognali; Todorov, Marin; Gardner, Scott (2017) (英語). RxSwift: Reactive Programming with Swift. Razeware LLC.. ISBN 978-1-942878-46-9. https://www.google.co.jp/books/edition/RxSwift/eXRJswEACAAJ?hl=ja 
32. ^ Meyer, Bertrand (1997) (英語). Object-oriented Software Construction. Prentice Hall PTR. ISBN 978-0-13-629155-8. https://www.google.co.jp/books/edition/Object_oriented_Software_Construction/xls_AQAAIAAJ?hl=ja&gbpv=1&bsq=Object-Oriented+Software+Construction&dq=Object-Oriented+Software+Construction&printsec=frontcover 
33. ^ Raymond, Eric S. (2003-09-23) (英語). The Art of UNIX Programming. Addison-Wesley Professional. ISBN 978-0-13-246588-5. https://www.google.co.jp/books/edition/The_Art_of_UNIX_Programming/H4q1t-jAcBIC?hl=ja&gbpv=1&dq=The+Art+of+UNIX+Programming&printsec=frontcover 
34. ^ Scott, Michael (2015-11-30) (英語). Programming Language Pragmatics. Elsevier. ISBN 978-0-12-410477-8. https://www.google.co.jp/books/edition/Programming_Language_Pragmatics/jM-cBAAAQBAJ?hl=ja&gbpv=1&dq=Programming+Language+Pragmatics&printsec=frontcover 
35. ^ Russinovich, Mark E.; Margosis, Aaron (2016-10-10) (英語). Troubleshooting with the Windows Sysinternals Tools. Microsoft Press. ISBN 978-0-13-398651-8. https://www.google.co.jp/books/edition/Troubleshooting_with_the_Windows_Sysinte/YQ86DQAAQBAJ?hl=ja&gbpv=1&dq=Troubleshooting+with+the+Windows+Sysinternals+Tools&printsec=frontcover 
36. ^ Savill, John (2016-12-19) (英語). Mastering Windows Server 2016 Hyper-V. John Wiley & Sons. ISBN 978-1-119-28618-9. https://www.google.co.jp/books/edition/Mastering_Windows_Server_2016_Hyper_V/c6-GDQAAQBAJ?hl=ja&gbpv=1&dq=Mastering+Windows+Server+2016+Hyper-V&printsec=frontcover 
37. ^ Love, Robert (2010-06-22) (英語). Linux Kernel Development. Pearson Education. ISBN 978-0-7686-9679-0. https://www.google.co.jp/books/edition/Linux_Kernel_Development/3MWRMYRwulIC?hl=ja&gbpv=1&dq=Linux+Kernel+Development&printsec=frontcover 
38. ^ Cooling, Jim (2017) (英語). Real-Time Operating Systems: Book 1 - the Theory. Independently Published. ISBN 978-1-5496-0894-0. https://www.google.co.jp/books/edition/Real_Time_Operating_Systems/o4WSswEACAAJ?hl=ja 
39. ^ Xiao, Perry (2018-07-23) (英語). Designing Embedded Systems and the Internet of Things (IoT) with the ARM mbed. John Wiley & Sons. ISBN 978-1-119-36399-6. https://www.google.co.jp/books/edition/Designing_Embedded_Systems_and_the_Inter/2v9cDwAAQBAJ?hl=ja&gbpv=0 
40. ^ ^{a b} Williams, Rob (2006) (英語). Real-time Systems Development. Elsevier Butterworth-Heinemann. ISBN 978-0-7506-6471-4. https://www.google.co.jp/books/edition/Real_time_Systems_Development/r1Z6ngEACAAJ?hl=ja 
41. ^ ^{a b} Webster, John G. (2009-02-03) (英語). Medical Instrumentation: Application and Design. John Wiley & Sons. ISBN 978-0-471-67600-3. https://www.google.co.jp/books/edition/Medical_Instrumentation/muRmDwAAQBAJ?hl=ja&gbpv=1&dq=Medical+Instrumentation:+Application+and+Design&printsec=frontcover 
42. ^ ^{a b} Navet, Nicolas; Simonot-Lion, Francoise (2008-12-20) (英語). Automotive Embedded Systems Handbook. Taylor & Francis. ISBN 978-0-8493-8026-6. https://www.google.co.jp/books/edition/_/1jE9mQEACAAJ?hl=ja&sa=X&ved=2ahUKEwicibDQmeqHAxX2hq8BHe1nA3sQ7_IDegQIFhAD 
43. ^ ^{a b} Elliott, Eric (2014-06-26) (英語). Programming JavaScript Applications: Robust Web Architecture with Node, HTML5, and Modern JS Libraries. "O'Reilly Media, Inc.". ISBN 978-1-4919-5027-2. https://www.google.co.jp/books/edition/Programming_JavaScript_Applications/jUfnAwAAQBAJ?hl=ja&gbpv=1&dq=Programming+JavaScript+Applications&printsec=frontcover 
44. ^ ^{a b} Casciaro, Mario; Mammino, Luciano (2016-07-18) (英語). Node.js Design Patterns. Packt Publishing Ltd. ISBN 978-1-78588-738-3. https://www.google.co.jp/books/edition/Node_js_Design_Patterns/55WqDQAAQBAJ?hl=ja&gbpv=1&dq=Node.js+Design+Patterns&printsec=frontcover 
45. ^ ^{a b c d e f g} Haverbeke, Marijn (2018-12-04) (英語). Eloquent JavaScript, 3rd Edition: A Modern Introduction to Programming. No Starch Press. ISBN 978-1-59327-951-6. https://www.google.co.jp/books/edition/Eloquent_JavaScript_3rd_Edition/FSVTDwAAQBAJ?hl=ja&gbpv=1&dq=Eloquent+JavaScript&printsec=frontcover 
46. ^ ^{a b c d e f} Simpson, Kyle (2015-02-23) (英語). You Don't Know JS: Async & Performance. "O'Reilly Media, Inc.". ISBN 978-1-4919-0520-3. https://www.google.co.jp/books/edition/You_Don_t_Know_JS_Async_Performance/pGvIBgAAQBAJ?hl=ja&gbpv=1&dq=You+Don%E2%80%99t+Know+JS:+Async+&+Performance&printsec=frontcover 
47. ^ ^{a b} Osmani, Addy (2012-08-20) (英語). Learning JavaScript Design Patterns. "O'Reilly Media, Inc.". ISBN 978-1-4493-3181-8. https://www.google.co.jp/books/edition/_/JYPEgK-1bZoC?hl=ja&sa=X&ved=2ahUKEwieksmlpeqHAxVmr1YBHRZMO7UQ7_IDegQIERAD 
48. ^ ^{a b} Bader, Dan (2017) (英語). Python Tricks: The Book. Ron Holland Designs. ISBN 978-1-7750933-0-5. https://www.google.co.jp/books/edition/Python_Tricks/BcN0swEACAAJ?hl=ja 
49. ^ Martelli, Alex; Ravenscroft, Anna; Holden, Steve (2017-04-07) (英語). Python in a Nutshell: A Desktop Quick Reference. "O'Reilly Media, Inc.". ISBN 978-1-4919-1386-4. https://www.google.co.jp/books/edition/Python_in_a_Nutshell/FrCgDgAAQBAJ?hl=ja&gbpv=1&dq=Python+in+a+Nutshell&printsec=frontcover 
50. ^ Beazley, David; Jones, Brian K. (2013-05-10) (英語). Python Cookbook: Recipes for Mastering Python 3. "O'Reilly Media, Inc.". ISBN 978-1-4493-5735-1. https://www.google.co.jp/books/edition/Python_Cookbook/S_SJ2LaZH8EC?hl=ja&gbpv=1&dq=Python+Cookbook&printsec=frontcover 
51. ^ Alchin, Marty (2010-06-15) (英語). Pro Python. Apress. ISBN 978-1-4302-2757-1. https://www.google.co.jp/books/edition/Pro_Python/hP8szQEACAAJ?hl=ja 
52. ^ ^{a b c d e} Crockford, Douglas (2008-05-08) (英語). JavaScript: The Good Parts: The Good Parts. "O'Reilly Media, Inc.". ISBN 978-0-596-55487-3. https://www.google.co.jp/books/edition/JavaScript_The_Good_Parts/PXa2bby0oQ0C?hl=ja&gbpv=1&printsec=frontcover 
53. ^ ^{a b c d e f g h} Tsvetinov, Nickolay (2015-06-24) (英語). Learning Reactive Programming with Java 8. Packt Publishing Ltd. ISBN 978-1-78528-250-8. https://www.google.co.jp/books/edition/Learning_Reactive_Programming_with_Java/5GT9CQAAQBAJ?hl=ja&gbpv=0 
54. ^ ^{a b c d e f} Sathyanarayanan, Prasanna Kumar; Atreya, Suraj (2016) (英語). Reactive Programming with Scala and Akka: Harness Reactive Programming to Build Scalable and Fault-tolerant Distributed Systems Using Scala and Akka. Packt Publishing. ISBN 978-1-78398-434-3. https://www.google.co.jp/books/edition/Reactive_Programming_with_Scala_and_Akka/W3msjwEACAAJ?hl=ja 
55. ^ ^{a b} Morgillo, Ivan (2015) (英語). RxJava Essentials: Learn Reactive Programming to Create Awesome Android and Java Apps. Packt Publishing. ISBN 978-1-78439-910-8. https://www.google.co.jp/books/edition/RxJava_Essentials/IQzrsgEACAAJ?hl=ja 
56. ^ ^{a b} Daniels, Paul; Atencio, Luis (2017-07-20) (英語). RxJS in Action. Simon and Schuster. ISBN 978-1-63835-170-2. https://www.google.co.jp/books/edition/RxJS_in_Action/mjszEAAAQBAJ?hl=ja&gbpv=1&dq=RxJS+in+Action&printsec=frontcover 
57. ^ ^{a b} Oliveira, Erich de Souza (2017-05-26) (英語). Mastering Reactive JavaScript. Packt Publishing Ltd. ISBN 978-1-78646-346-3. https://www.google.co.jp/books/edition/Mastering_Reactive_JavaScript/nnc5DwAAQBAJ?hl=ja&gbpv=1&dq=Mastering+Reactive+JavaScript&printsec=frontcover 
58. ^ ^{a b c} Hailperin, Max (2007) (英語). Operating Systems and Middleware: Supporting Controlled Interaction. Max Hailperin. ISBN 978-0-534-42369-8. https://www.google.co.jp/books/edition/Operating_Systems_and_Middleware/nWeKVg-HDmEC?hl=ja&gbpv=1&dq=Operating+Systems+and+Middleware:+Supporting+Controlled+Interaction&printsec=frontcover 
59. ^ Li, Qing; Yao, Caroline (2003-01-04) (英語). Real-Time Concepts for Embedded Systems. CRC Press. ISBN 978-1-57820-124-2. https://www.google.co.jp/books/edition/Real_Time_Concepts_for_Embedded_Systems/RzP3iH0BSW0C?hl=ja&gbpv=1&dq=Real-Time+Concepts+for+Embedded+Systems&printsec=frontcover 
60. ^ ^{a b} Mall, Rajib (2006) (英語). Real-Time Systems: Theory and Practice. Prentice Hall Imprint. ISBN 978-81-317-7076-4. https://www.google.co.jp/books/edition/_/k5lDzQEACAAJ?hl=ja&sa=X&ved=2ahUKEwicx426seqHAxWBc_UHHb4QAcEQre8FegQIIxAC 
61. ^ Buttazzo, Giorgio C. (2011-09-10) (英語). Hard Real-Time Computing Systems: Predictable Scheduling Algorithms and Applications. Springer Science & Business Media. ISBN 978-1-4614-0676-1. https://www.google.co.jp/books/edition/Hard_Real_Time_Computing_Systems/h6q-e4Q_rzgC?hl=ja&gbpv=0 
62. ^ ^{a b c} Bloch, Joshua『Effective Java』丸善出版、2018年10月。ISBN 978-4-621-30325-2。https://www.google.co.jp/books/edition/Effective_Java/5jm6vQEACAAJ?hl=ja。 
63. ^ Stevans, W. Richard (2011) (英語). Advanced Programming in the Unix Environment. Pearson. https://www.google.co.jp/books/edition/Advanced_Programming_in_the_Unix_Environ/w13gtAEACAAJ?hl=ja 
64. ^ Kernighan, Brian W.; Ritchie, Dennis M. (1988) (英語). The C Programming Language. Prentice Hall. ISBN 978-0-13-110370-2. https://www.google.co.jp/books/edition/The_C_Programming_Language/HHhGAAAAYAAJ?hl=ja&gbpv=1&bsq=The+C+Programming+Language&dq=The+C+Programming+Language&printsec=frontcover 
65. ^ Rochkind, Marc J. (2004-04-29) (英語). Advanced UNIX Programming. Pearson Education. ISBN 978-0-13-246613-4. https://www.google.co.jp/books/edition/Advanced_UNIX_Programming/vlM72G-1VDkC?hl=ja&gbpv=1&dq=Advanced+UNIX+Programming&printsec=frontcover 
66. ^ Love, Robert (2007-11-15) (英語). Linux System Programming: Talking Directly to the Kernel and C Library. O'Reilly Media. ISBN 978-0-596-00958-8. https://www.google.co.jp/books/edition/_/SyAhnAEACAAJ?hl=ja&sa=X&ved=2ahUKEwi6rdaQu-yHAxWhklYBHf7iBxAQ7_IDegQIDRAD 
67. ^ Butenhof, David R. (1997) (英語). Programming with POSIX Threads. Addison-Wesley Professional. ISBN 978-0-201-63392-4. https://www.google.co.jp/books/edition/Programming_with_POSIX_Threads/_xvnuFzo7q0C?hl=ja&gbpv=1&dq=Programming+with+POSIX+Threads&printsec=frontcover 
68. ^ Metcalf, Michael; Reid, John Ker; Cohen, Malcolm (2004) (英語). Fortran 95/2003 Explained. Oxford University Press. ISBN 978-0-19-852692-6. https://www.google.co.jp/books/edition/Fortran_95_2003_Explained/eZYE4zKLnbQC?hl=ja 
69. ^ ^{a b} Metcalf, Michael; Reid, John; Cohen, Malcolm (2011-03-24) (英語). Modern Fortran Explained. Oxford University Press. ISBN 978-0-19-960141-7. https://www.google.co.jp/books/edition/Modern_Fortran_Explained/V7UVDAAAQBAJ?hl=ja&gbpv=1&dq=Modern+Fortran+Explained&printsec=frontcover 
70. ^ Nyhoff, Larry R.; Leestma, Sanford (1996) (英語). FORTRAN 77 for Engineers and Scientists: With an Introduction to FORTRAN 90. Prentice Hall. ISBN 978-0-13-363003-9. https://www.google.co.jp/books/edition/FORTRAN_77_for_Engineers_and_Scientists/e4Q_AQAAIAAJ?hl=ja&gbpv=1&bsq=Fortran+77+for+Engineers+and+Scientists+with+an+Introduction+to+Fortran+90&dq=Fortran+77+for+Engineers+and+Scientists+with+an+Introduction+to+Fortran+90&printsec=frontcover 
71. ^ Chapman, Barbara; Jost, Gabriele; Pas, Ruud Van Der (2007-10-12) (英語). Using OpenMP: Portable Shared Memory Parallel Programming. MIT Press. ISBN 978-0-262-53302-7. https://www.google.co.jp/books/edition/Using_OpenMP/MeFLQSKmaJYC?hl=ja&gbpv=1&dq=Using+OpenMP:+Portable+Shared+Memory+Parallel+Programming&printsec=frontcover 
72. ^ Sterling, Thomas; Brodowicz, Maciej; Anderson, Matthew (2017-12-05) (英語). High Performance Computing: Modern Systems and Practices. Morgan Kaufmann. ISBN 978-0-12-420215-3. https://www.google.co.jp/books/edition/High_Performance_Computing/qOHIBAAAQBAJ?hl=ja&gbpv=1&dq=High+Performance+Computing:+Modern+Systems+and+Practices&printsec=frontcover 
73. ^ Norvig, Peter (1992) (英語). Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp. Morgan Kaufmann. ISBN 978-1-55860-191-8. https://www.google.co.jp/books/edition/_/QzGuHnDhvZIC?hl=ja&sa=X&ved=2ahUKEwjN35TjvuyHAxX2rlYBHTbBEGMQ7_IDegQICxAC 
74. ^ Touretzky, David S. (1990) (英語). Common LISP: A Gentle Introduction to Symbolic Computation. Benjamin/Cummings Pub.. ISBN 978-0-8053-0492-3. https://www.google.co.jp/books/edition/_/PKMZAQAAIAAJ?hl=ja&sa=X&ved=2ahUKEwi7_f6Tv-yHAxW0slYBHV3KBLYQ7_IDegQIGRAE 
75. ^ Kiczales, Gregor; Rivieres, Jim Des; Bobrow, Daniel G. (1991-07-30) (英語). The Art of the Metaobject Protocol. MIT Press. ISBN 978-0-262-61074-2. https://www.google.co.jp/books/edition/The_Art_of_the_Metaobject_Protocol/3X5Gnudn3k0C?hl=ja&gbpv=1&dq=The+Art+of+the+Metaobject+Protocol&printsec=frontcover 
76. ^ ^{a b} Queinnec, Christian (2003-12-04) (英語). Lisp in Small Pieces. Cambridge University Press. ISBN 978-0-521-54566-2. https://www.google.co.jp/books/edition/Lisp_in_Small_Pieces/81mFK8pqh5EC?hl=ja&gbpv=1&dq=Lisp+in+Small+Pieces&printsec=frontcover 
77. ^ Graham, Paul (1994) (英語). On Lisp: Advanced Techniques for Common Lisp. Prentice Hall. ISBN 978-0-13-030552-7. https://www.google.co.jp/books/edition/_/jbJQAAAAMAAJ?hl=ja&sa=X&ved=2ahUKEwj_1KvLwOyHAxXGqFYBHdMWCHMQ7_IDegQICRAD 
78. ^ Hoyte, Doug (2008) (英語). Let Over Lambda: 50 Years of Lisp. Doug Hoyte/HCSW and Hoytech production. ISBN 978-1-4357-1275-1. https://www.google.co.jp/books/edition/Let_Over_Lambda/vbTONwAACAAJ?hl=ja 
79. ^ Seibel, Peter (2006-11-01) (英語). Practical Common Lisp. Springer. ISBN 978-1-4302-0017-8. https://www.google.co.jp/books/edition/Practical_Common_Lisp/dVJvr8PtCMUC?hl=ja&gbpv=1&dq=Practical+Common+Lisp&printsec=frontcover 
80. ^ Stern, Nancy B.; Stern, Robert A.; Ley, James P. (2006) (英語). COBOL for the 21st Century. Wiley. ISBN 978-0-471-72261-8. https://www.google.co.jp/books/edition/COBOL_for_the_21st_Century/TlUiAQAAIAAJ?hl=ja&gbpv=1&bsq=COBOL+for+the+21st+Century&dq=COBOL+for+the+21st+Century&printsec=frontcover 
81. ^ Brown, Gary DeWard (1999) (英語). Advanced COBOL for Structured and Object-Oriented Programming. Wiley. ISBN 978-0-471-31481-3. https://www.google.co.jp/books/edition/Advanced_COBOL_for_Structured_and_Object/q3w_AQAAIAAJ?hl=ja&gbpv=1&bsq=Advanced+COBOL+for+Structured+and+Object-Oriented+Programming&dq=Advanced+COBOL+for+Structured+and+Object-Oriented+Programming&printsec=frontcover 
82. ^ ^{a b} Richardson, Chris L. (2003) (英語). COBOL and Visual Basic on .NET: A Guide for the Reformed Mainframe Programmer. Apress. ISBN 978-1-59059-048-5. https://www.google.co.jp/books/edition/_/S7xgd-wuLZYC?hl=ja&sa=X&ved=2ahUKEwjlzLyowuyHAxX5sVYBHSlmC1IQ7_IDegQIDxAC 
83. ^ ^{a b} Murach, Mike; Prince, Anne; Menendez, Raul (2004) (英語). Murach's Mainframe COBOL. Mike Murach & Associates, Incorporated. ISBN 978-1-890774-24-0. https://www.google.co.jp/books/edition/Murach_s_Mainframe_COBOL/kDcNAAAACAAJ?hl=ja 
84. ^ ^{a b} Josuttis, Nicolai M. (2012) (英語). The C++ Standard Library: A Tutorial and Reference. Addison-Wesley Professional. ISBN 978-0-321-62321-8. https://www.google.co.jp/books/edition/The_C++_Standard_Library/gUhE8po4jgAC?hl=ja&gbpv=1&dq=The+C+++Standard+Library:+A+Tutorial+and+Reference&printsec=frontcover 
85. ^ ^{a b} Williams, Anthony (2012) (英語). C++ Concurrency in Action: Practical Multithreading. Manning. ISBN 978-1-933988-77-1. https://www.google.co.jp/books/edition/C++_Concurrency_in_Action/EttPPgAACAAJ?hl=ja 
86. ^ ^{a b} Fertig, Andreas (2021-11-26) (英語). Programming with C++20: Concepts, Coroutines, Ranges, and more. Fertig Publications. ISBN 978-3-949323-01-0. https://www.google.co.jp/books/edition/Programming_with_C++20/uyUhEAAAQBAJ?hl=ja&gbpv=1&dq=Programming+with+C++20:+Concepts,+Coroutines,+Ranges,+and+More&printsec=frontcover 
87. ^ ^{a b} Bancila, Marius (2020-09-11) (英語). Modern C++ Programming Cookbook: Master C++ core language and standard library features, with over 100 recipes, updated to C++20. Packt Publishing Ltd. ISBN 978-1-80020-620-5. https://www.google.co.jp/books/edition/Modern_C++_Programming_Cookbook/8d_8DwAAQBAJ?hl=ja&gbpv=1&dq=Modern+C+++Programming+Cookbook&printsec=frontcover 
88. ^ ^{a b} Webber, Adam Brooks (2003) (英語). Modern Programming Languages: A Practical Introduction. Franklin, Beedle & Associates. ISBN 978-1-887902-76-2. https://www.google.co.jp/books/edition/Modern_Programming_Languages/RUd5QgAACAAJ?hl=ja 
89. ^ Cant?, Marco (2003-03-14) (英語). Mastering Delphi 7. Wiley. ISBN 978-0-7821-4201-3. https://www.google.co.jp/books/edition/Mastering_Delphi_7/degwmH4jsvIC?hl=ja&gbpv=1&bsq=Mastering+Delphi+7&dq=Mastering+Delphi+7&printsec=frontcover 
90. ^ Jensen, Cary; D, Cary Jensen Ph (2011-03-23) (英語). Delphi in Depth: ClientDataSets. CreateSpace Independent Publishing Platform. ISBN 978-1-4610-0858-3. https://www.google.co.jp/books/edition/Delphi_in_Depth/4eexuAAACAAJ?hl=ja 
91. ^ ^{a b c} Barnes, John Gilbert Presslie (2014-06-19) (英語). Programming in Ada 2012. Cambridge University Press. ISBN 978-1-107-42481-4. https://www.google.co.jp/books/edition/Programming_in_Ada_2012/qiWjAwAAQBAJ?hl=ja&gbpv=1&dq=Programming+in+Ada+2012&printsec=frontcover 
92. ^ McCormick, John W.; Singhoff, Frank; Hugues, Jérôme (2011-04-07) (英語). Building Parallel, Embedded, and Real-Time Applications with Ada. Cambridge University Press. ISBN 978-1-139-50000-5. https://www.google.co.jp/books/edition/Building_Parallel_Embedded_and_Real_Time/3NuhuYhNn_UC?hl=ja&gbpv=1&dq=Building+Parallel,+Embedded,+and+Real-Time+Applications+with+Ada&printsec=frontcover 
93. ^ McCormick, John W.; Chapin, Peter C. (2015-08-31) (英語). Building High Integrity Applications with SPARK. Cambridge University Press. ISBN 978-1-107-04073-1. https://www.google.co.jp/books/edition/Building_High_Integrity_Applications_wit/Yh9TCgAAQBAJ?hl=ja&gbpv=1&dq=Building+High+Integrity+Applications+with+SPARK&printsec=frontcover 
94. ^ Taft, S. Tucker; Duff, Robert A.; Brukardt, Randall L.; Ploedereder, Erhard; Leroy, Pascal (2007-05-18) (英語). Ada 2005 Reference Manual. Language and Standard Libraries: International Standard ISO/IEC 8652/1995(E) with Technical Corrigendum 1 and Amendment 1. Springer. ISBN 978-3-540-69336-9. https://www.google.co.jp/books/edition/Ada_2005_Reference_Manual_Language_and_S/WAprCQAAQBAJ?hl=ja&gbpv=1&dq=Ada+2005+Reference+Manual&printsec=frontcover 
95. ^ Real, Jorge; Vardanega, Tullio (2010-06-16) (英語). Reliable Software Technologies - Ada-Europe 2010: 15th Ada-Europe International Conference on Reliabel Software Technologies, Valencia, Spain, June 14-18, 2010, Proceedings. Springer. ISBN 978-3-642-13550-7. https://www.google.co.jp/books/edition/Reliable_Software_Technologies_Ada_Europ/1tKpCAAAQBAJ?hl=ja&gbpv=0 
96. ^ ^{a b} Dokuka, Oleh; Lozynskyi, Igor (2018-10-08) (英語). Hands-On Reactive Programming in Spring 5: Build cloud-ready, reactive systems with Spring 5 and Project Reactor. Packt Publishing Ltd. ISBN 978-1-78728-729-7. https://www.google.co.jp/books/edition/Hands_On_Reactive_Programming_in_Spring/3iZyDwAAQBAJ?hl=ja&gbpv=1&dq=Hands-On+Reactive+Programming+in+Spring+5&printsec=frontcover 
97. ^ Karanam, Ranga (2019) (英語). Mastering Spring 5. Packt Publishing. https://www.google.co.jp/books/edition/Mastering_Spring_5/HyeLzQEACAAJ?hl=ja 
98. ^ ^{a b c} foy, brian d (2014-01-09) (英語). Mastering Perl: Creating Professional Programs with Perl. "O'Reilly Media, Inc.". ISBN 978-1-4493-6497-7. https://www.google.co.jp/books/edition/Mastering_Perl/7cWMAgAAQBAJ?hl=ja&gbpv=1&dq=Mastering+Perl&printsec=frontcover 
99. ^ ^{a b} Schwartz, Randal L.; foy, brian d; Phoenix, Tom (2016-10-06) (英語). Learning Perl: Making Easy Things Easy and Hard Things Possible. "O'Reilly Media, Inc.". ISBN 978-1-4919-5429-4. https://www.google.co.jp/books/edition/Learning_Perl/3Fc4DQAAQBAJ?hl=ja&gbpv=1&dq=Learning+Perl+2016&pg=PR2&printsec=frontcover 
100. ^ Cozens, Simon (2005-06-28) (英語). Advanced Perl Programming: The Worlds Most Highly Developed Perl Tutorial. "O'Reilly Media, Inc.". ISBN 978-1-4493-7891-2. https://www.google.co.jp/books/edition/Advanced_Perl_Programming/WMmlodYkdNYC?hl=ja&gbpv=1&dq=Advanced+Perl+Programming&printsec=frontcover 
101. ^ Lutz, Mark (2013-06-12) (英語). Learning Python: Powerful Object-Oriented Programming. "O'Reilly Media, Inc.". ISBN 978-1-4493-5569-2. https://www.google.co.jp/books/edition/Learning_Python/4pgQfXQvekcC?hl=ja&gbpv=1&dq=Learning+Python+2013&printsec=frontcover 
102. ^ ^{a b} Forbes, Elliot (2017-08-16) (英語). Learning Concurrency in Python. Packt Publishing Ltd. ISBN 978-1-78728-316-9. https://www.google.co.jp/books/edition/Learning_Concurrency_in_Python/hJZGDwAAQBAJ?hl=ja&gbpv=1&dq=Learning+Concurrency+in+Python&printsec=frontcover 
103. ^ ^{a b} Picard, Romain (2018-10-25) (英語). Hands-On Reactive Programming with Python: Event-driven development unraveled with RxPY. Packt Publishing Ltd. ISBN 978-1-78913-275-5. https://www.google.co.jp/books/edition/Hands_On_Reactive_Programming_with_Pytho/1_50DwAAQBAJ?hl=ja&gbpv=1&dq=Hands-On+Reactive+Programming+with+Python&printsec=frontcover 
104. ^ Albahari, Joseph; Albahari, Ben (2015) (英語). C# 6.0 in a Nutshell. O'Reilly. https://www.google.co.jp/books/edition/C_6_0_in_a_Nutshell/IqS8zwEACAAJ?hl=ja 
105. ^ ^{a b} Thomas, David; Fowler, Chad; Hunt, Andrew (2013) (英語). Programming Ruby 1.9 & 2.0: The Pragmatic Programmers' Guide. Pragmatic Bookshelf. ISBN 978-1-937785-49-9. https://www.google.co.jp/books/edition/Programming_Ruby_1_9_2_0/2LulngEACAAJ?hl=ja 
106. ^ Hartl, Michael (2016-11-17) (英語). Ruby on Rails Tutorial: Learn Web Development with Rails. Addison-Wesley Professional. ISBN 978-0-13-459750-8. https://www.google.co.jp/books/edition/Ruby_on_Rails_Tutorial/ePuCDQAAQBAJ?hl=ja&gbpv=1&dq=Ruby+on+Rails+Tutorial:+Learn+Web+Development+with+Rails&printsec=frontcover 
107. ^ Dymo, Alexander (2015-11-19) (英語). Ruby Performance Optimization: Why Ruby is Slow, and How to Fix It. Pragmatic Bookshelf. ISBN 978-1-68050-458-3. https://www.google.co.jp/books/edition/Ruby_Performance_Optimization/Vg9QDwAAQBAJ?hl=ja&gbpv=0 
108. ^ Perrotta, Paolo (2014) (英語). Metaprogramming Ruby 2: Program Like the Ruby Pros. Pragmatic Bookshelf. ISBN 978-1-941222-12-6. https://www.google.co.jp/books/edition/Metaprogramming_Ruby_2/V0iToAEACAAJ?hl=ja 
109. ^ Hartl, Michael (2022-10-24) (英語). Ruby on Rails Tutorial: Learn Web Development with Rails. Addison-Wesley Professional. ISBN 978-0-13-804997-3. https://www.google.co.jp/books/edition/Ruby_on_Rails_Tutorial/-NnPEAAAQBAJ?hl=ja&gbpv=1&dq=Ruby+on+Rails+Tutorial:+Learn+Web+Development+with+Rails&printsec=frontcover 
110. ^ ^{a b c} Donovan, Alan A. A.; Kernighan, Brian W. (2015-11-16) (英語). The Go Programming Language. Addison-Wesley Professional. ISBN 978-0-13-419056-3. https://www.google.co.jp/books/edition/The_Go_Programming_Language/SJHvCgAAQBAJ?hl=ja&gbpv=1&dq=The+Go+Programming+Language&printsec=frontcover 
111. ^ ^{a b} Gomez, Guillaume; Boucher, Antoni (2018-01-11) (英語). Rust Programming By Example: Enter the world of Rust by building engaging, concurrent, reactive, and robust applications. Packt Publishing Ltd. ISBN 978-1-78847-030-8. https://www.google.co.jp/books/edition/Rust_Programming_By_Example/qNRJDwAAQBAJ?hl=ja&gbpv=1&dq=Rust+Programming+By+Example&printsec=frontcover 
112. ^ ^{a b c} McNamara, Tim (2021-09-07) (英語). Rust in Action. Simon and Schuster. ISBN 978-1-63835-622-6. https://www.google.co.jp/books/edition/Rust_in_Action/AfQ1EAAAQBAJ?hl=ja&gbpv=1&dq=Rust+in+Action&printsec=frontcover 
113. ^ Troutwine, Brian L. (2018-05-31) (英語). Hands-On Concurrency with Rust: Confidently build memory-safe, parallel, and efficient software in Rust. Packt Publishing Ltd. ISBN 978-1-78847-835-9. https://www.google.co.jp/books/edition/Hands_On_Concurrency_with_Rust/FHxeDwAAQBAJ?hl=ja&gbpv=1&dq=Hands-On+Concurrency+with+Rust&printsec=frontcover 
114. ^ ^{a b} Powers, David (2019) (英語). PHP 7 Solutions: Dynamic Web Design Made Easy. Apress. ISBN 978-1-4842-4339-8. https://www.google.co.jp/books/edition/PHP_7_Solutions/hQidzQEACAAJ?hl=ja 
115. ^ ^{a b c} Lockhart, Josh (2015-02-16) (英語). Modern PHP: New Features and Good Practices. "O'Reilly Media, Inc.". ISBN 978-1-4919-0499-2. https://www.google.co.jp/books/edition/Modern_PHP/rnSpBgAAQBAJ?hl=ja&gbpv=1&dq=Modern+PHP:+New+Features+and+Good+Practices&printsec=frontcover 
116. ^ Ali, Junade (2016-09-28) (英語). Mastering PHP Design Patterns. Packt Publishing Ltd. ISBN 978-1-78588-342-2. https://www.google.co.jp/books/edition/Mastering_PHP_Design_Patterns/DIFcDgAAQBAJ?hl=ja&gbpv=1&dq=Mastering+PHP+Design+Patterns&printsec=frontcover 
117. ^ Hoffman, Jon (2019-04-30) (英語). Mastering Swift 5: Deep dive into the latest edition of the Swift programming language, 5th Edition. Packt Publishing Ltd. ISBN 978-1-78913-273-1. https://www.google.co.jp/books/edition/Mastering_Swift_5/YCyWDwAAQBAJ?hl=ja&gbpv=1&dq=Mastering+Swift+5&printsec=frontcover 
118. ^ ^{a b c} Mathias, Matthew; Gallagher, John; Ward, Mikey (2020-10-21) (英語). Swift Programming: The Big Nerd Ranch Guide. Pearson Technology Group. ISBN 978-0-13-526659-5. https://www.google.com/books/edition/_/EtrPEAAAQBAJ?sa=X&ved=2ahUKEwiRwrut5-yHAxWK0DQHHWF3AKsQ7_IDegQIKhAf 
119. ^ Keur, Christian; Hillegass, Aaron (2020-05-05) (英語). IOS Programming: The Big Nerd Ranch Guide. Pearson Education. ISBN 978-0-13-526402-7. https://www.google.co.jp/books/edition/_/nwlsuQEACAAJ?hl=ja&sa=X&ved=2ahUKEwjvirGZ6OyHAxXcs1YBHdIkI-MQ7_IDegQIDxAE 
120. ^ Gardner, Scott; Mishali, Shai; Pillet, Florent (2019-12-05) (英語). Combine: Asynchronous Programming with Swift (First Edition). Razeware LLC. ISBN 978-1-942878-84-1. https://www.google.co.jp/books/edition/Combine/j--nzAEACAAJ?hl=ja 
121. ^ ^{a b c} Jemerov, Dmitry; Isakova, Svetlana (2017-02-03) (英語). Kotlin in Action. Simon and Schuster. ISBN 978-1-63835-369-0. https://www.google.co.jp/books/edition/Kotlin_in_Action/OzkzEAAAQBAJ?hl=ja&gbpv=1&dq=Kotlin+in+Action&printsec=frontcover 
122. ^ ^{a b} Greenhalgh, David; Skeen, Josh; Bailey, Andrew (2021-10-05) (英語). Kotlin Programming: The Big Nerd Ranch Guide. Pearson Technology Group. ISBN 978-0-13-687048-7. https://www.google.co.jp/books/edition/Kotlin_Programming/FNrPEAAAQBAJ?hl=ja&gbpv=1&dq=Kotlin+Programming:+The+Big+Nerd+Ranch+Guide&printsec=frontcover 
123. ^ Leiva, Antonio (2018) (英語). Kotlin for Android Developers: Learn Kotlin the Easy Way While Developing an Android App. Leanpub. ISBN 978-1-5300-7561-4. https://www.google.co.jp/books/edition/Kotlin_for_Android_Developers/cdT1jwEACAAJ?hl=ja 
124. ^ ^{a b c} Chiusano, Paul; Bjarnason, Runar (2014-09-01) (英語). Functional Programming in Scala. Simon and Schuster. ISBN 978-1-63835-395-9. https://www.google.co.jp/books/edition/Functional_Programming_in_Scala/GjszEAAAQBAJ?hl=ja&gbpv=1&dq=Functional+Programming+in+Scala&printsec=frontcover 
125. ^ ^{a b} Horstmann, Cay (2016) (英語). Scala for the Impatient, Second Edition. Addison-Wesley Professional. https://www.google.co.jp/books/edition/Scala_for_the_Impatient_Second_Edition/tSw6zQEACAAJ?hl=ja 
126. ^ Karim, Md Rezaul; Alla, Sridhar (2017-07-25) (英語). Scala and Spark for Big Data Analytics: Explore the concepts of functional programming, data streaming, and machine learning. Packt Publishing Ltd. ISBN 978-1-78355-050-0. https://www.google.co.jp/books/edition/Scala_and_Spark_for_Big_Data_Analytics/7eZDDwAAQBAJ?hl=ja&gbpv=1&dq=Scala+and+Spark+for+Big+Data+Analytics&printsec=frontcover 
127. ^ Roestenburg, Raymond; Williams, Rob; Bakker, Robertus (2016-09-20) (英語). Akka in Action. Simon and Schuster. ISBN 978-1-63835-293-8. https://www.google.co.jp/books/edition/Akka_in_Action/QTozEAAAQBAJ?hl=ja&gbpv=1&dq=Akka+in+Action&printsec=frontcover 
128. ^ ^{a b c} Marlow, Simon (2013-07-12) (英語). Parallel and Concurrent Programming in Haskell: Techniques for Multicore and Multithreaded Programming. "O'Reilly Media, Inc.". ISBN 978-1-4493-3592-2. https://www.google.co.jp/books/edition/Parallel_and_Concurrent_Programming_in_H/wSkRAAAAQBAJ?hl=ja&gbpv=0 
129. ^ ^{a b c} Allen, Christopher; Moronuki, Julie (2016-07) (英語). Haskell Programming from First Principles. Lorepub LLC. ISBN 978-1-945388-03-3. https://www.google.co.jp/books/edition/Haskell_Programming_from_First_Principle/5FaXDAEACAAJ?hl=ja 
130. ^ ^{a b c} Thomas, Dave (2018-05-18) (英語). Programming Elixir ≥ 1.6: Functional |> Concurrent |> Pragmatic |> Fun. Pragmatic Bookshelf. ISBN 978-1-68050-613-6. https://www.google.co.jp/books/edition/Programming_Elixir_1_6/ttJfDwAAQBAJ?hl=ja&gbpv=1&printsec=frontcover 
131. ^ ^{a b} Juric, Saša (2019-01-12) (英語). Elixir in Action. Manning. ISBN 978-1-61729-502-7. https://www.google.co.jp/books/edition/Elixir_in_Action/Dt6xtAEACAAJ?hl=ja 
132. ^ Hao, Benjamin Tan Wei (2016-09-25) (英語). The Little Elixir & OTP Guidebook. Simon and Schuster. ISBN 978-1-63835-345-4. https://www.google.co.jp/books/edition/The_Little_Elixir_OTP_Guidebook/DzkzEAAAQBAJ?hl=ja&gbpv=1&dq=The+Little+Elixir+&+OTP+Guidebook&printsec=frontcover 
133. ^ ^{a b} Trelford, Phillip; Petricek, Tomas (2014-12-16) (英語). F# Deep Dives. Simon and Schuster. ISBN 978-1-63835-308-9. https://www.google.co.jp/books/edition/F_Deep_Dives/VTkzEAAAQBAJ?hl=ja&gbpv=1&dq=F#+Deep+Dives&printsec=frontcover 
134. ^ ^{a b c} Syme, Don; Granicz, Adam; Cisternino, Antonio (2015-12-31) (英語). Expert F# 4.0. Apress. ISBN 978-1-4842-0740-6. https://www.google.co.jp/books/edition/Expert_F_4_0/XKhPCwAAQBAJ?hl=ja&gbpv=1&dq=Expert+F#+4.0&printsec=frontcover 
135. ^ Terrell, Riccardo (2018-06-05) (英語). Concurrency in .NET: Modern patterns of concurrent and parallel programming. Simon and Schuster. ISBN 978-1-63835-564-9. https://www.google.co.jp/books/edition/Concurrency_in_NET/vzgzEAAAQBAJ?hl=ja&gbpv=0 
136. ^ Helfrick, Albert D. (2012) (英語). Principles of Avionics. Avionics Communications, Incorporated. ISBN 978-1-885544-29-2. https://www.google.co.jp/books/edition/Principles_of_Avionics/YlFJuAAACAAJ?hl=ja 
137. ^ ^{a b} Gray, Jim; Reuter, Andreas (1992-09-30) (英語). Transaction Processing: Concepts and Techniques. Elsevier. ISBN 978-0-08-051955-5. https://www.google.co.jp/books/edition/Transaction_Processing/VFKbCgAAQBAJ?hl=ja&gbpv=1&dq=Transaction+Processing:+Concepts+and+Techniques&printsec=frontcover 
138. ^ ^{a b} Bernstein, Philip A.; Newcomer, Eric (2009-07-24) (英語). Principles of Transaction Processing. Morgan Kaufmann. ISBN 978-0-08-094841-6. https://www.google.co.jp/books/edition/Principles_of_Transaction_Processing/LmHgK5KKrQQC?hl=ja&gbpv=1&dq=Principles+of+Transaction+Processing&printsec=frontcover 
139. ^ ^{a b} Garcia-Molina, Hector; Ullman, Jeffrey D.; Widom, Jennifer (2009) (英語). Database Systems: The Complete Book. Pearson Prentice Hall. ISBN 978-0-13-187325-4. https://www.google.co.jp/books/edition/Database_Systems/pk5GAQAAIAAJ?hl=ja&gbpv=1&bsq=Database+Systems:+The+Complete+Book&dq=Database+Systems:+The+Complete+Book&printsec=frontcover 
140. ^ ^{a b} Elmasri, Ramez; Navathe, Shamkant B. (2015-09-25) (英語). Fundamentals of Database Systems. Pearson Education. ISBN 978-0-13-397124-8. https://www.google.co.jp/books/edition/Fundamentals_of_Database_Systems/tRybCgAAQBAJ?hl=ja 
141. ^ Hwang, Kai; Fox, Geoffrey C.; Dongarra, J. J. (2012) (英語). Distributed and Cloud Computing: From Parallel Processing to the Internet of Things. Morgan Kaufmann. ISBN 978-0-12-385880-1. https://www.google.co.jp/books/edition/_/1u6buAAACAAJ?hl=ja&sa=X&ved=2ahUKEwj8i5a0v-qHAxX9r1YBHd3bE0UQ7_IDegQIDhAE 
142. ^ ^{a b c} Erl, Thomas; Puttini, Ricardo; Mahmood, Zaigham (2013-05-02) (英語). Cloud Computing: Concepts, Technology & Architecture. Prentice Hall. ISBN 978-0-13-338751-3. https://www.google.co.jp/books/edition/Cloud_Computing/czCiJ6sbhpAC?hl=ja&gbpv=1&bsq=Cloud+Computing:+Concepts,+Technology+&+Architecture&dq=Cloud+Computing:+Concepts,+Technology+&+Architecture&printsec=frontcover 
143. ^ Buyya, Rajkumar; Broberg, James; Goscinski, Andrzej M. (2010-12-17) (英語). Cloud Computing: Principles and Paradigms. John Wiley & Sons. ISBN 978-1-118-00220-9. https://www.google.co.jp/books/edition/Cloud_Computing/S1NvRRd77rQC?hl=ja&gbpv=1&dq=Cloud+Computing:+Principles+and+Paradigms&printsec=frontcover 
144. ^ Kavis, Michael J. (2014-01-28) (英語). Architecting the Cloud: Design Decisions for Cloud Computing Service Models (SaaS, PaaS, and IaaS). John Wiley & Sons. ISBN 978-1-118-82646-1. https://www.google.co.jp/books/edition/Architecting_the_Cloud/NcrDAgAAQBAJ?hl=ja&gbpv=1&dq=Architecting+the+Cloud:+Design+Decisions+for+Cloud+Computing+Service+Models+(SaaS,+PaaS,+and+IaaS)&printsec=frontcover 
145. ^ White, Tom (2015-03-25) (英語). Hadoop: The Definitive Guide: Storage and Analysis at Internet Scale. "O'Reilly Media, Inc.". ISBN 978-1-4919-0170-0. https://www.google.co.jp/books/edition/Hadoop_The_Definitive_Guide/6BmkBwAAQBAJ?hl=ja&gbpv=1&dq=Hadoop:+The+Definitive+Guide&printsec=frontcover 
146. ^ Karau, Holden; Konwinski, Andy; Wendell, Patrick; Zaharia, Matei (2015-01-28) (英語). Learning Spark: Lightning-Fast Big Data Analysis. "O'Reilly Media, Inc.". ISBN 978-1-4493-5906-5. https://www.google.co.jp/books/edition/Learning_Spark/2eptBgAAQBAJ?hl=ja&gbpv=1&dq=Learning+Spark:+Lightning-Fast+Big+Data+Analysis&printsec=frontcover 
147. ^ Garrison, Justin; Nova, Kris (2017-10-25) (英語). Cloud Native Infrastructure: Patterns for Scalable Infrastructure and Applications in a Dynamic Environment. "O'Reilly Media, Inc.". ISBN 978-1-4919-8427-7. https://www.google.co.jp/books/edition/Cloud_Native_Infrastructure/zlk7DwAAQBAJ?hl=ja&gbpv=0 
148. ^ ^{a b c d} Oaks, Scott (2014-04-10) (英語). Java Performance: The Definitive Guide: Getting the Most Out of Your Code. "O'Reilly Media, Inc.". ISBN 978-1-4493-6354-3. https://www.google.co.jp/books/edition/Java_Performance_The_Definitive_Guide/aIhUAwAAQBAJ?hl=ja&gbpv=1&dq=Java+Performance:+The+Definitive+Guide&printsec=frontcover 
149. ^ Pinedo, Michael L. (2012-01-07) (英語). Scheduling: Theory, Algorithms, and Systems. Springer Science & Business Media. ISBN 978-1-4614-2361-4. https://www.google.co.jp/books/edition/Scheduling/QRiDnuXSnVwC?hl=ja&gbpv=1&dq=Scheduling:+Theory,+Algorithms,+and+Systems&printsec=frontcover 
150. ^ Cheng, Albert M. K. (2003-03-27) (英語). Real-Time Systems: Scheduling, Analysis, and Verification. John Wiley & Sons. ISBN 978-0-471-46084-8. https://www.google.co.jp/books/edition/Real_Time_Systems/pPvCtrIMXv0C?hl=ja&gbpv=1&dq=Real-Time+Systems:+Scheduling,+Analysis,+and+Verification&printsec=frontcover 
151. ^ Fink, Jason; Sherer, Matthew (2002) (英語). Linux Performance Tuning and Capacity Planning. Sams. ISBN 978-0-672-32081-1. https://www.google.co.jp/books/edition/Linux_Performance_Tuning_and_Capacity_Pl/0zfh5NTE7TAC?hl=ja&gbpv=1&bsq=Linux+Performance+Tuning+and+Capacity+Planning&dq=Linux+Performance+Tuning+and+Capacity+Planning&printsec=frontcover 
152. ^ Johnson, Sandra K. (2005-05-27) (英語). Performance Tuning for Linux Servers. Pearson Education. ISBN 978-0-13-713628-5. https://www.google.co.jp/books/edition/Performance_Tuning_for_Linux_Servers/zH0tPQAACAAJ?hl=ja 
153. ^ ^{a b} Harchol-Balter, Mor (2013-02-18) (英語). Performance Modeling and Design of Computer Systems: Queueing Theory in Action. Cambridge University Press. ISBN 978-1-139-62013-0. https://www.google.co.jp/books/edition/Performance_Modeling_and_Design_of_Compu/y1cgAwAAQBAJ?hl=ja&gbpv=0 
154. ^ Lilja, David J. (2005-09-08) (英語). Measuring Computer Performance: A Practitioner's Guide. Cambridge University Press. ISBN 978-1-139-42778-4. https://www.google.co.jp/books/edition/Measuring_Computer_Performance/jb68T-OuIC4C?hl=ja&gbpv=0 
155. ^ Menascé, Daniel A.; Almeida, Virgilio A. F.; Dowdy, Lawrence W.; Dowdy, Larry (2004) (英語). Performance by Design: Computer Capacity Planning by Example. Prentice Hall Professional. ISBN 978-0-13-090673-1. https://www.google.co.jp/books/edition/Performance_by_Design/sxE931Medm4C?hl=ja&gbpv=1&dq=Performance+by+Design:+Computer+Capacity+Planning+by+Example&printsec=frontcover 
156. ^ Menascé, Daniel A.; Almeida, Virgilio A. F. (2002) (英語). Capacity Planning for Web Services: Metrics, Models, and Methods. Prentice Hall PTR. ISBN 978-0-13-065903-3. https://www.google.co.jp/books/edition/Capacity_Planning_for_Web_Services/s99QAAAAMAAJ?hl=ja&gbpv=1&bsq=Capacity+Planning+for+Web+Services:+Metrics,+Models,+and+Methods&dq=Capacity+Planning+for+Web+Services:+Metrics,+Models,+and+Methods&printsec=frontcover 

関連項目

• 関数型プログラミング
• 並行プログラミング
• 非同期処理
• リアクティブプログラミング
• コールバック
• コールバック地獄
• Future
• Promise
• async/await
• リアクティブ拡張
• Observable
• Subject
• バックプレッシャー
• イベントループ