ディレクトリ
オペレーティングシステムの開発の歴史1。
1）。パンチカード
1枚のカードだけを使用することができます部屋の
CPU使用率が非常に低いです
2）。オンラインバッチ処理システム
これは、コンピュータ室を使用する複数のユーザーをサポートしています。
3）オフラインバッチ処理システム
高速テープはCPUの使用率を向上させる、読み出し速度を向上させます。
4）マルチチャネル技術
シングルチャネル：
（シングルコアの場合）、複数のユーザーがCPUのシリアル一の実行ずつ、プログラムの実装を完了するために次の唯一のプログラムを使用しています。
マルチチャンネル
（事例ベースのシングルコア）：プログラムは、メモリBにプログラムをロードし、CPUのBを使用して終了プログラムがCPU（これも一つだけCPU）を用いて開始します。
（1）空間多重
簡単には、使用する複数のユーザに提供することができます。
時間上の（2）多重化（******）
+ハンドオーバ保存された状態（現在の状態が、プログラムの切り替えを保存されています）
IO操作：入力（）、印刷（）、time.sleep（）。
1）CPUは、直ちに現在実行中のCPUのプログラムを使用する権利遮断し、IO操作が発生した場合
の利点を：高いCPU使用率
CPU時間を使用してプログラムが長すぎる場合は2）（最も一般的に使用される時間のカップセット）、CPU使用権直ちに他のプログラムに、現在の番組を切断あります。
短所：プログラムの実施の速度を低下させます。
並行並列：
同時実行：それは、実行中のように見えます。（前後複数のスイッチングに対応したプログラム）
パラレル：同時にマルチコアケースに複数のプログラムを実行しながら、実際のランニング。
2.プロセス
手続きやプロセス
プログラム：コードの束
で実行するコードの束を処理：プロセス
プロセスのスケジューリング：
1. FCFSスケジューリング：
、Bプログラム、プログラムが最初に来る場合は、最初のCPUを占有しました
短所：最初にプログラムを使用すると、プログラムはB待っている必要があり
ます。2.短いジョブ優先順位スケジューリング
時間の短いあり、Bプログラム、優先度スケジューリングを使用します
短所：長い実行で使用するプログラムの短い終わりにすべての時間を待つ必要があります
3ラウンドロビンプロセスの
1秒等に、n個の手順をロード、CPU 1秒で実行される時、時刻nにスロット（N部）
4.分類キューフィードバック
に実行優先度多層
--1レベル：最高の優先順位
--2レベル：第二、等
--- 3レベル
スリーステート・プログラムが実行されています。
レディ状態：このプログラムに入ります状態はディスパッチするすべての準備ができて作成されます。
状態の実行：プロセススケジューラの後、実行状態に入ります。
ブロッキング状態：IO操作処理が発生した方は、ブロッキング状態になります。IOの終了した場合、彼らは準備状態を再入力する必要があります。
同期および非同期：
これは、タスクの提出を指します。
同期：2つのタスクが最初のタスクを提出する際の仕事は、タスクは次のタスクに実行の終了を待たなければならない場合、提出する必要がある場合。
非同期：2つのタスクが提出した場合、2番目のタスクは、次の2つのタスクを同時に実行することができます待つ必要はありません。
#同步演示程序：程序一直在运行，并未将CPU的运行权限交出去
import time
def test():
# IO操作
# time.sleep(3)
# 计算操作
num = 1
for line in range(1000000000000000000000000):
num += 1
if __name__ == '__main__':
test()
print('hello tank')ブロッキングとノンブロッキング：
ブロッキング：IOは確かに、ブロッキングが発生します、状態を遮断
状態を実行し、レディ状態：非ブロッキング
インタビューの質問：同期、非同期、非ブロッキングは同じ概念、それをブロックしていますか？
待機は必ずしも長すぎるためにCPU集約型のタスクがあるかもしれない、ブロックされていないので、彼らは混同することはできません、同じ概念ではありません！
CPUの使用率を向上させる最大化：不要なIO操作を最小限に抑えます
2つの方法でプロセスを作成します。
方法1：タスクの定義
Windowsではエラーが発生しやすいシステムがプログラムを作成するときに、親プロセスの実行時間を親プロセスの子プロセスを呼び出し、子プロセスを呼び出すので、（Windowsは、コードのコピーとしてファイルをインポートします）再帰的で、その結果、予定し続けます。この問題は、Windowsのシステム（子プロセスを作成するプロセスは、一度実行現在の親プロセスのコードをリロードするWindowsシステムトレイ）、再コピー現在のサブプロセスコードになり、MacとLinuxシステムで表示されます部品は、個別に実行しました。
import time
from multiprocessing import Process
def task(name):
print(f'{name}的任务开始执行')
time.sleep(1)
print(f'{name}的任务已经结束')
#target=执行函数的地址，agrs里面填元组，且元素是task的函数的参数
p = Process(target=task,args=('jason',))
#向操作系统提交创建进程的任务
p.start()
print('主进程')プログラムを実行している主な関数を記述するために、子プロセスは親プロセスの前に実行されませんが、それは登場再帰を発行しませんので、主な機能は、から（サブプロセスである主な機能）を実行しています。
import time
from multiprocessing import Process
def task(name):
print(f'{name}的任务开始执行')
time.sleep(1)
print(f'{name}的任务已经结束')
if __name__ == '__main__':
#target=执行函数的地址，agrs里面填元组，且元素是task的函数的参数
p = Process(target=task,args=('jason',))
#向操作系统提交创建进程的任务
p.start()
print('主进程')第二の方法：カスタムクラス、および継承プロセス
ここでは主と子プロセスは独立して、それらの間の相互の、それぞれが自分の実行、並列に実行されています。
from multiprocessing import Process
import time
class MyProcess(Process):
def run(self):
print('任务开始执行')
time.sleep(1)
print('任务已经结束')
if __name__ == '__main__':
p = MyProcess()
p.start()
print('主进程')
主进程
任务开始执行
任务已经结束メソッドに参加
役割は：子プロセスが終了時に、親プロセスが終了されるように、オペレーティングシステムに指示します。
from multiprocessing import Process
import time
class MyProcess(Process):
def run(self):
print('任务开始执行')
time.sleep(1)
print('任务已经结束')
if __name__ == '__main__':
p = MyProcess()
p.start()#告诉操作系统，开启子进程
p.join()#告诉操作系统，等子进程结束后，父进程再结束
print('主进程')
任务开始执行
任务已经结束
主进程使用するために子プロセスの数を開くときより参加
import time
from multiprocessing import Process
def task(name,n):
print(f'{name}的任务开始执行')
time.sleep(n)
print(f'{name}的任务已经结束')
if __name__ == '__main__':
#target=执行函数的地址，agrs里面填元组，且元素是task的函数的参数
p1 = Process(target=task,args=('jason',1))
p2 = Process(target=task, args=('xiaoming',2))
p3 = Process(target=task, args=('xiaohua',3))
#向操作系统提交创建进程的任务
p1.start()
p2.start()
p3.start()
p1.join()
p2.join()
p3.join()
print('主进程')
jason的任务开始执行
xiaoming的任务开始执行
xiaohua的任务开始执行
jason的任务已经结束
xiaoming的任务已经结束
xiaohua的任务已经结束
主进程プロセス間のデータは、子プロセス、互いに分離されており、主なプロセスは、実行時に互いに独立して、自分の名前空間を持つことになります。
x = 100
def func():
print('执行func函数。。。')
global x
x = 200
print(f'子程序x:{x}')
if __name__ == '__main__':
p = Process(target=func)
p.start()
print(f'主程序x{x}')
主程序x100
执行func函数。。。
子程序x:200
プロセスIDについて
プロセスIDは、実装プロセスであり、無作為にオペレーティングシステムは、プロセスIDが不足している場合はこの数字の文字列は、制限されているデジタルチャネリングに割り当てられたオペレーティングシステムは、システムは、もはや新しいプロセスが実行されていません。
courent_processは（）のpid :.サブプロセスIDを取得します
os.getpidは（）：メインプロセスのPID番号を取得します
os.getppid（）：（親に対するp）親プロセスのメイン処理を取得
cmdは、プロセスIDを表示：タスクリスト| findstrのプロセスID
2つの条件の回復プロセスID：
1.join、子供はメインプロセスに再循環させることができます。
2.メインプロセスが正常に終了し、子プロセスはメインプロセスにリサイクルされます。
子どもの生存方法かどうかをチェックします
子プロセス.is_alive（）はTrueまたはFalseのブール値を返します。
子プロセスを終了させる方法
子プロセス.terminate（）は、オペレーティングシステムが子プロセスを強制終了することができます
from multiprocessing import Process
import time
from multiprocessing import current_process
def task(name):
print(f'{name} start...', current_process().pid)
time.sleep(1)
print(f'{name} over..', current_process().pid)
if __name__ == '__main__':
p = Process(target=task, args=('jason', ))
p.start() # 告诉操作系统，开启子进程
# 判断子进程是否存活
print(p.is_alive())
# 直接告诉操作系统，终止 子进程
#p.terminate()
time.sleep(0.1)#此处让子进程暂停0.1秒是因为子进程与主进程是并行执行的，而打印操作是在主进程中进行的，如果不暂停的话有可能，主进程执行到最后一步时，子进程还没执行到强制终止的指令，这样就无法得到正确的打印接过了
# 判断子进程是否存活
print(p.is_alive())
p.join() # 告诉操作系统，等子进程结束后，父进程再结束。
True
True
jason start... 8988
jason over.. 8988
プログラムを終了するには、子プロセスを追加した後
from multiprocessing import Process
import time
from multiprocessing import current_process
def task(name):
print(f'{name} start...', current_process().pid)
time.sleep(1)
print(f'{name} over..', current_process().pid)
if __name__ == '__main__':
p = Process(target=task, args=('jason', ))
p.start() # 告诉操作系统，开启子进程
# 判断子进程是否存活
print(p.is_alive())
# 直接告诉操作系统，终止 子进程
p.terminate()
time.sleep(0.1)#此处让子进程暂停0.1秒是因为子进程与主进程是并行执行的，而打印操作是在主进程中进行的，如果不暂停的话有可能，主进程执行到最后一步时，子进程还没执行到强制终止的指令，这样就无法得到正确的打印接过了
# 判断子进程是否存活
print(p.is_alive())
p.join() # 告诉操作系统，等子进程结束后，父进程再结束。
True
Falseゾンビプロセスと孤立（理解して）：
ゾンビプロセス：子プロセスは終了しましたが、PID番号が破壊されていないが残っています、
短所：職業PID番号のフットプリント。
孤児プロセス：子プロセスを指し、まだ実行されているが、親プロセスが予期せず終了します。
オペレーティングシステムは、子供がデーモンである親プロセスを、持っていないの回復を支援するために、孤児院を提供します。
デーモン
メインプロセスを指した後、作成され、すべての子プロセスの主なプロセスは、リカバリの終了に続きました。
from multiprocessing import Process
import time
from multiprocessing import current_process
def task(name):
print(f'{name} start...', current_process().pid)
time.sleep(1)
print(f'{name} over..', current_process().pid)
if __name__ == '__main__':
p = Process(target=task, args=('jason', ))
p.daemon = True# True代表该进程是守护进程
p.start() # 告诉操作系统，开启子进程
# 判断子进程是否存活
print(p.is_alive())
# 直接告诉操作系统，终止 子进程
p.terminate()
time.sleep(0.1)#此处让子进程暂停0.1秒是因为子进程与主进程是并行执行的，而打印操作是在主进程中进行的，如果不暂停的话有可能，主进程执行到最后一步时，子进程还没执行到强制终止的指令，这样就无法得到正确的打印接过了
# 判断子进程是否存活
print(p.is_alive())
p.join() # 告诉操作系统，等子进程结束后，父进程再结束。