ระบบปฏิบัติการเบื้องต้น

สวัสดีฮับ! ฉันอยากจะนำเสนอชุดบทความแปลของวรรณกรรมเรื่องหนึ่งที่น่าสนใจในความคิดเห็นของฉัน - OSTEP เนื้อหานี้จะตรวจสอบการทำงานของระบบปฏิบัติการที่มีลักษณะคล้ายยูนิกซ์อย่างลึกซึ้ง กล่าวคือ การทำงานกับกระบวนการ ตัวกำหนดเวลาต่างๆ หน่วยความจำ และส่วนประกอบอื่น ๆ ที่คล้ายกันซึ่งประกอบเป็นระบบปฏิบัติการสมัยใหม่ คุณสามารถดูต้นฉบับของวัสดุทั้งหมดได้ที่นี่ ที่นี่. โปรดทราบว่าการแปลจัดทำขึ้นอย่างไม่เป็นมืออาชีพ (ค่อนข้างอิสระ) แต่ฉันหวังว่าฉันจะคงความหมายทั่วไปไว้

งานห้องปฏิบัติการในเรื่องนี้สามารถพบได้ที่นี่:

• ต้นฉบับ: Pages.cs.wisc.edu/~remzi/OSTEP/Homework/homework.html
• ต้นฉบับ: github.com/remzi-arpacidusseau/ostep-code
• การปรับตัวส่วนตัวของฉัน: github.com/bykvaadm/OS/tree/master/ostep

ส่วนอื่น ๆ :

• ส่วนที่ 1: บทนำ

คุณสามารถตรวจสอบช่องของฉันได้ที่ โทรเลข =)

มาดูสิ่งที่เป็นนามธรรมพื้นฐานที่สุดที่ระบบปฏิบัติการมอบให้กับผู้ใช้: กระบวนการ คำจำกัดความของกระบวนการนั้นค่อนข้างง่าย - มันคือ โปรแกรมที่กำลังรันอยู่. ตัวโปรแกรมเองเป็นสิ่งที่ไม่มีชีวิตชีวาซึ่งอยู่บนดิสก์ - เป็นชุดคำสั่งและอาจเป็นข้อมูลคงที่บางส่วนที่รอการเปิดตัว ระบบปฏิบัติการคือตัวรับไบต์เหล่านั้นและรันมัน โดยเปลี่ยนโปรแกรมให้กลายเป็นสิ่งที่มีประโยชน์
บ่อยครั้งที่ผู้ใช้ต้องการเรียกใช้โปรแกรมมากกว่าหนึ่งโปรแกรมในเวลาเดียวกัน เช่น คุณสามารถเรียกใช้เบราว์เซอร์ เกม เครื่องเล่นสื่อ โปรแกรมแก้ไขข้อความ และอื่นๆ บนแล็ปท็อปของคุณได้ ในความเป็นจริง ระบบทั่วไปสามารถรันกระบวนการได้หลายสิบหรือหลายร้อยกระบวนการพร้อมกัน ข้อเท็จจริงนี้ทำให้ระบบใช้งานง่ายขึ้น คุณไม่ต้องกังวลว่า CPU จะว่างหรือไม่ คุณเพียงแค่รันโปรแกรมเท่านั้น

สิ่งนี้ทำให้เกิดปัญหา: จะสร้างภาพลวงตาของ CPU จำนวนมากได้อย่างไร ระบบปฏิบัติการจะสร้างภาพลวงตาของ CPU จำนวนเกือบไม่มีที่สิ้นสุดได้อย่างไร แม้ว่าคุณจะมี CPU จริงเพียงตัวเดียวก็ตาม

ระบบปฏิบัติการสร้างภาพลวงตานี้ผ่านการจำลองเสมือนของ CPU ด้วยการเริ่มกระบวนการหนึ่งแล้วหยุดมัน เริ่มกระบวนการอื่น และอื่นๆ ระบบปฏิบัติการสามารถรักษาภาพลวงตาว่ามี CPU เสมือนจำนวนมาก ซึ่งในความเป็นจริงแล้วจะมีตัวประมวลผลทางกายภาพหนึ่งตัวหรือมากกว่านั้น เทคนิคนี้เรียกว่า การแบ่งทรัพยากร CPU ตามเวลา. เทคนิคนี้ช่วยให้ผู้ใช้สามารถรันกระบวนการพร้อมกันได้มากเท่าที่ต้องการ ต้นทุนของโซลูชันนี้คือประสิทธิภาพ เนื่องจากหาก CPU ถูกใช้ร่วมกันโดยหลายกระบวนการ แต่ละกระบวนการก็จะได้รับการประมวลผลช้าลง
หากต้องการใช้การจำลองเสมือนของ CPU และโดยเฉพาะอย่างยิ่งเพื่อให้ทำงานได้ดี ระบบปฏิบัติการต้องการการสนับสนุนทั้งระดับต่ำและระดับสูง เรียกว่าแนวรับระดับต่ำ กลไก เป็นวิธีการหรือโปรโตคอลระดับต่ำที่ใช้ส่วนที่จำเป็นของฟังก์ชันการทำงาน ตัวอย่างของฟังก์ชันดังกล่าวคือการสลับบริบทซึ่งทำให้ระบบปฏิบัติการสามารถหยุดโปรแกรมหนึ่งและเรียกใช้โปรแกรมอื่นบนโปรเซสเซอร์ได้ การแบ่งเวลานี้ถูกนำมาใช้ในระบบปฏิบัติการสมัยใหม่ทั้งหมด
ด้านบนของกลไกเหล่านี้คือตรรกะบางอย่างที่สร้างไว้ในระบบปฏิบัติการ ในรูปแบบของ "นโยบาย" นโยบาย เป็นอัลกอริธึมการตัดสินใจบางอย่างสำหรับระบบปฏิบัติการ ตัวอย่างเช่น นโยบายดังกล่าวจะตัดสินใจว่าควรเปิดโปรแกรมใด (จากรายการคำสั่ง) ก่อน ตัวอย่างเช่นปัญหานี้จะได้รับการแก้ไขด้วยนโยบายที่เรียกว่า ตัวกำหนดเวลา (นโยบายการกำหนดตารางเวลา) และเมื่อเลือกโซลูชัน จะมีการชี้แนะโดยข้อมูลต่างๆ เช่น ประวัติการเริ่มต้น (โปรแกรมใดที่เปิดตัวนานที่สุดในนาทีสุดท้าย) โหลดที่กระบวนการนี้ดำเนินการ (ประเภทของโปรแกรมที่เปิดตัว) ตัวชี้วัดประสิทธิภาพ (ไม่ว่าจะเป็นระบบหรือไม่ ได้รับการปรับให้เหมาะสมสำหรับการโต้ตอบแบบโต้ตอบหรือสำหรับปริมาณงาน ) และอื่นๆ

สิ่งที่เป็นนามธรรม: กระบวนการ

สิ่งที่เป็นนามธรรมของโปรแกรมที่ทำงานอยู่ซึ่งดำเนินการโดยระบบปฏิบัติการคือสิ่งที่เราเรียกว่า กระบวนการ. ดังที่ได้กล่าวไว้ข้างต้น กระบวนการเป็นเพียงโปรแกรมที่กำลังรันอยู่ในช่วงเวลาใดเวลาหนึ่ง โปรแกรมที่เราสามารถรับข้อมูลสรุปจากทรัพยากรระบบต่างๆ ที่โปรแกรมนี้เข้าถึงหรือได้รับผลกระทบระหว่างการดำเนินการ
เพื่อทำความเข้าใจองค์ประกอบของกระบวนการ คุณต้องเข้าใจสถานะของระบบ: สิ่งที่โปรแกรมสามารถอ่านหรือเปลี่ยนแปลงได้ระหว่างการดำเนินการ ในเวลาใดก็ตาม คุณต้องเข้าใจว่าองค์ประกอบใดของระบบมีความสำคัญต่อการทำงานของโปรแกรม
องค์ประกอบที่ชัดเจนอย่างหนึ่งของระบบระบุว่ากระบวนการนี้รวมอยู่ด้วย память. คำแนะนำอยู่ในหน่วยความจำ ข้อมูลที่โปรแกรมอ่านหรือเขียนจะอยู่ในหน่วยความจำด้วย ดังนั้น หน่วยความจำที่กระบวนการสามารถจัดการได้ (เรียกว่าพื้นที่ที่อยู่) จึงเป็นส่วนหนึ่งของกระบวนการ
ส่วนหนึ่งของสถานะระบบคือการลงทะเบียน คำสั่งจำนวนมากมุ่งเป้าไปที่การเปลี่ยนค่าของรีจิสเตอร์หรือการอ่านค่า ดังนั้นรีจิสเตอร์จึงกลายเป็นส่วนสำคัญของการดำเนินการของกระบวนการ
ควรสังเกตว่าสถานะของเครื่องนั้นถูกสร้างขึ้นจากรีจิสเตอร์พิเศษบางตัวด้วย ตัวอย่างเช่น, IP - ตัวชี้คำสั่ง — ตัวชี้ไปยังคำสั่งที่โปรแกรมกำลังดำเนินการอยู่ นอกจากนี้ยังมี ตัวชี้สแต็ก และเกี่ยวข้องกับมัน ตัวชี้เฟรมซึ่งใช้ในการจัดการ: พารามิเตอร์ฟังก์ชัน ตัวแปรท้องถิ่น และที่อยู่ผู้ส่งกลับ
ในที่สุด โปรแกรมต่างๆ มักจะเข้าถึง ROM (หน่วยความจำแบบอ่านอย่างเดียว) ข้อมูล “I/O” (อินพุต/เอาท์พุต) นี้ควรมีรายการไฟล์ที่เปิดโดยกระบวนการในปัจจุบัน

ประมวลผล API

เพื่อที่จะปรับปรุงความเข้าใจของเราเกี่ยวกับวิธีการทำงานของกระบวนการ ลองศึกษาตัวอย่างของการเรียกระบบที่ควรรวมไว้ในอินเทอร์เฟซของระบบปฏิบัติการ API เหล่านี้มีให้ใช้งานในรูปแบบเดียวหรือแบบอื่นบนระบบปฏิบัติการใดก็ได้

● สร้างบัญชีตัวแทน (การสร้าง): ระบบปฏิบัติการจะต้องมีวิธีการบางอย่างที่ช่วยให้คุณสามารถสร้างกระบวนการใหม่ได้ เมื่อคุณป้อนคำสั่งลงในเทอร์มินัลหรือเปิดแอปพลิเคชันโดยดับเบิลคลิกที่ไอคอน การโทรจะถูกส่งไปยังระบบปฏิบัติการเพื่อสร้างกระบวนการใหม่ จากนั้นเปิดโปรแกรมที่ระบุ
● การถอด: เนื่องจากมีอินเทอร์เฟซสำหรับสร้างกระบวนการ ระบบปฏิบัติการจึงควรจัดให้มีความสามารถในการบังคับให้ลบกระบวนการออกด้วย โปรแกรมส่วนใหญ่จะเริ่มต้นและสิ้นสุดโดยอัตโนมัติในขณะที่ทำงาน มิฉะนั้นผู้ใช้ต้องการที่จะฆ่าพวกเขาได้ ดังนั้นอินเทอร์เฟซเพื่อหยุดกระบวนการจึงจะมีประโยชน์
● รอ (กำลังรอ): บางครั้งการรอให้กระบวนการเสร็จสิ้นก็มีประโยชน์ ดังนั้นจึงมีอินเทอร์เฟซบางส่วนที่ให้ความสามารถในการรอ
● การควบคุมเบ็ดเตล็ด (การควบคุมต่างๆ): นอกเหนือจากการฆ่าและรอกระบวนการแล้ว ยังมีวิธีการควบคุมอื่นๆ อีกด้วย ตัวอย่างเช่น ระบบปฏิบัติการส่วนใหญ่มีความสามารถในการหยุดกระบวนการ (หยุดการดำเนินการในช่วงระยะเวลาหนึ่ง) จากนั้นจึงดำเนินการต่อ (ดำเนินการต่อไป)
● Status (สถานะ): มีอินเทอร์เฟซที่หลากหลายสำหรับการรับข้อมูลบางอย่างเกี่ยวกับสถานะของกระบวนการ เช่น ระยะเวลาที่กระบวนการทำงานหรือสถานะปัจจุบันอยู่ในสถานะใด

การสร้างกระบวนการ: รายละเอียด

สิ่งที่น่าสนใจประการหนึ่งคือการที่โปรแกรมต่างๆ ถูกแปลงเป็นกระบวนการได้อย่างไร โดยเฉพาะอย่างยิ่งวิธีที่ระบบปฏิบัติการรับและรันโปรแกรม กระบวนการนี้ถูกสร้างขึ้นอย่างไร
ก่อนอื่น OS จะต้องโหลดรหัสโปรแกรมและข้อมูลคงที่ลงในหน่วยความจำ (ลงในพื้นที่ที่อยู่ของกระบวนการ) โดยปกติโปรแกรมจะอยู่บนดิสก์หรือโซลิดสเตทไดรฟ์ในรูปแบบปฏิบัติการบางรูปแบบ ดังนั้นกระบวนการโหลดโปรแกรมและข้อมูลคงที่ลงในหน่วยความจำต้องการให้ระบบปฏิบัติการสามารถอ่านไบต์เหล่านั้นจากดิสก์และวางไว้ที่ไหนสักแห่งในหน่วยความจำ

ในระบบปฏิบัติการยุคแรกๆ กระบวนการโหลดเสร็จสิ้นอย่างกระตือรือร้น ซึ่งหมายความว่าโค้ดทั้งหมดถูกโหลดลงในหน่วยความจำก่อนที่โปรแกรมจะเปิดตัว ระบบปฏิบัติการสมัยใหม่ทำสิ่งนี้อย่างเกียจคร้าน นั่นคือการโหลดโค้ดหรือข้อมูลเฉพาะเมื่อโปรแกรมต้องการในระหว่างการดำเนินการเท่านั้น

เมื่อโค้ดและข้อมูลคงที่ถูกโหลดลงในหน่วยความจำ OS แล้ว ยังมีบางสิ่งที่ต้องทำก่อนที่กระบวนการจะสามารถทำงานได้ ต้องจัดสรรหน่วยความจำจำนวนหนึ่งสำหรับสแต็ก โปรแกรมใช้สแต็กสำหรับตัวแปรโลคัล พารามิเตอร์ฟังก์ชัน และที่อยู่ผู้ส่งกลับ. ระบบปฏิบัติการจะจัดสรรหน่วยความจำนี้และมอบให้กับกระบวนการ สแต็กยังสามารถจัดสรรด้วยอาร์กิวเมนต์บางตัวได้ โดยเฉพาะสแต็กจะเติมพารามิเตอร์ของฟังก์ชัน main() เช่น ด้วยอาร์เรย์ของ argc และ argv

ระบบปฏิบัติการอาจจัดสรรหน่วยความจำบางส่วนให้กับฮีปของโปรแกรมด้วย โปรแกรมใช้ฮีปเพื่อร้องขอข้อมูลที่จัดสรรแบบไดนามิกอย่างชัดเจน. โปรแกรมขอพื้นที่นี้โดยการเรียกใช้ฟังก์ชัน มัลลอค () และล้างมันอย่างชัดเจนโดยการเรียกใช้ฟังก์ชัน ฟรี(). ฮีปจำเป็นสำหรับโครงสร้างข้อมูล เช่น ชีตที่เชื่อมโยง ตารางแฮช ต้นไม้ และอื่นๆ ในตอนแรก หน่วยความจำจำนวนเล็กน้อยจะถูกจัดสรรให้กับฮีป แต่เมื่อเวลาผ่านไป เมื่อโปรแกรมทำงาน ฮีปจะสามารถขอหน่วยความจำเพิ่มเติมผ่านการเรียกไลบรารี API malloc() ระบบปฏิบัติการมีส่วนร่วมในกระบวนการจัดสรรหน่วยความจำเพิ่มเติมเพื่อช่วยตอบสนองการโทรเหล่านี้

ระบบปฏิบัติการยังจะดำเนินการเริ่มต้นโดยเฉพาะงานที่เกี่ยวข้องกับ I/O ตัวอย่างเช่น บนระบบ UNIX แต่ละกระบวนการโดยดีฟอลต์จะมีตัวอธิบายไฟล์ที่เปิดอยู่ 3 ตัว สำหรับอินพุต เอาต์พุต และข้อผิดพลาดมาตรฐาน ที่จับเหล่านี้ช่วยให้โปรแกรมสามารถอ่านอินพุตจากเทอร์มินัลและแสดงข้อมูลบนหน้าจอได้

ดังนั้น โดยการโหลดโค้ดและข้อมูลคงที่ลงในหน่วยความจำ การสร้างและการเริ่มต้นสแต็ก และการทำงานอื่นๆ ที่เกี่ยวข้องกับการปฏิบัติงาน I/O ระบบปฏิบัติการจะเตรียมขั้นตอนสำหรับกระบวนการที่จะดำเนินการ สุดท้ายนี้ยังมีงานสุดท้ายเหลืออยู่ นั่นคือ การรันโปรแกรมผ่านจุดเริ่มต้นที่เรียกว่าฟังก์ชัน main() ด้วยการเรียกใช้ฟังก์ชัน main() ระบบปฏิบัติการจะถ่ายโอนการควบคุม CPU ไปยังกระบวนการที่สร้างขึ้นใหม่ ดังนั้นโปรแกรมจึงเริ่มทำงาน

สถานะกระบวนการ

ตอนนี้เราเข้าใจแล้วว่ากระบวนการคืออะไรและถูกสร้างขึ้นอย่างไร เรามาแสดงรายการสถานะกระบวนการที่สามารถทำได้กันดีกว่า ในรูปแบบที่ง่ายที่สุด กระบวนการสามารถอยู่ในสถานะใดสถานะหนึ่งเหล่านี้:
● เล่น. เมื่อทำงาน กระบวนการจะทำงานบนโปรเซสเซอร์ ซึ่งหมายความว่ากำลังดำเนินการตามคำสั่ง
● พร้อม. ในสถานะพร้อม กระบวนการพร้อมที่จะรัน แต่ด้วยเหตุผลบางประการ ระบบปฏิบัติการจึงไม่ดำเนินการตามเวลาที่กำหนด
● อุดตัน. ในสถานะที่ถูกบล็อค กระบวนการจะดำเนินการบางอย่างที่ป้องกันไม่ให้พร้อมที่จะดำเนินการจนกว่าเหตุการณ์บางอย่างจะเกิดขึ้น ตัวอย่างทั่วไปอย่างหนึ่งคือ เมื่อกระบวนการเริ่มต้นการดำเนินการ IO กระบวนการนั้นจะถูกบล็อกเพื่อให้กระบวนการอื่นสามารถใช้โปรเซสเซอร์ได้

คุณสามารถจินตนาการถึงสถานะเหล่านี้ได้ในรูปของกราฟ ดังที่เราเห็นในภาพ สถานะของกระบวนการสามารถเปลี่ยนแปลงได้ระหว่าง RUNNING และ READY ขึ้นอยู่กับดุลยพินิจของระบบปฏิบัติการ เมื่อสถานะของกระบวนการเปลี่ยนจาก READY เป็น RUNNING หมายความว่ากระบวนการได้รับการกำหนดเวลาแล้ว ในทิศทางตรงกันข้าม - ลบออกจากเค้าโครง ในขณะที่กระบวนการถูกบล็อก ตัวอย่างเช่น ฉันเริ่มต้นการดำเนินการ IO ระบบปฏิบัติการจะคงไว้ในสถานะนี้จนกว่าเหตุการณ์บางอย่างจะเกิดขึ้น เช่น IO เสร็จสิ้น ในขณะนี้การเปลี่ยนไปสู่สถานะ READY และอาจเข้าสู่สถานะ RUNNING ทันทีหาก ​​OS ตัดสินใจเช่นนั้น
ลองดูตัวอย่างว่ากระบวนการทั้งสองเคลื่อนที่ผ่านสถานะเหล่านี้อย่างไร ขั้นแรก ลองจินตนาการว่ากระบวนการทั้งสองกำลังทำงานอยู่ และแต่ละกระบวนการใช้เพียง CPU เท่านั้น ในกรณีนี้รัฐของพวกเขาจะมีลักษณะเช่นนี้

ในตัวอย่างต่อไปนี้ กระบวนการแรกหลังจากทำงานไประยะหนึ่ง จะร้องขอ IO และเข้าสู่สถานะ BLOCKED เพื่อให้กระบวนการอื่นทำงาน (รูปที่ 1.4) ระบบปฏิบัติการเห็นว่ากระบวนการ 0 ไม่ได้ใช้ CPU และเริ่มกระบวนการที่ 1 ขณะที่กระบวนการที่ 1 กำลังทำงานอยู่ IO จะเสร็จสิ้น และสถานะของกระบวนการ 0 จะเปลี่ยนเป็น READY ในที่สุด กระบวนการที่ 1 ก็เสร็จสมบูรณ์ และเมื่อเสร็จสิ้นแล้ว กระบวนการที่ 0 ก็เริ่มต้น ดำเนินการ และเสร็จสิ้นการทำงาน

โครงสร้างข้อมูล

ระบบปฏิบัติการนั้นเป็นโปรแกรม และเหมือนกับโปรแกรมอื่นๆ ก็คือมีโครงสร้างข้อมูลสำคัญบางส่วนที่คอยติดตามข้อมูลที่เกี่ยวข้องต่างๆ เพื่อติดตามสถานะของแต่ละกระบวนการระบบปฏิบัติการจะรองรับบางส่วน รายการกระบวนการ สำหรับกระบวนการทั้งหมดในสถานะ READY และข้อมูลเพิ่มเติมบางส่วนเพื่อติดตามกระบวนการที่กำลังทำงานอยู่ นอกจากนี้ระบบปฏิบัติการควรตรวจสอบกระบวนการที่ถูกบล็อก หลังจากที่ IO เสร็จสิ้น ระบบปฏิบัติการจะต้องปลุกกระบวนการที่จำเป็นและทำให้กระบวนการอยู่ในสถานะพร้อมที่จะรัน

ตัวอย่างเช่น ระบบปฏิบัติการจะต้องคงสถานะของการลงทะเบียนตัวประมวลผลไว้ ในขณะที่กระบวนการหยุดลง สถานะของการลงทะเบียนจะถูกเก็บไว้ในพื้นที่ที่อยู่ของกระบวนการ และในขณะที่การดำเนินการยังคงดำเนินต่อไป ค่าของการลงทะเบียนจะถูกเรียกคืนและดำเนินการตามกระบวนการนี้ต่อไป

นอกจากสถานะพร้อม บล็อค และกำลังทำงานแล้ว ยังมีสถานะอื่นๆ อีก บางครั้ง ในขณะที่สร้าง กระบวนการอาจอยู่ในสถานะ INIT ในที่สุด กระบวนการสามารถอยู่ในสถานะ FINAL เมื่อกระบวนการเสร็จสิ้นแล้ว แต่ข้อมูลยังไม่ได้รับการล้าง บนระบบ UNIX สถานะนี้เรียกว่า กระบวนการซอมบี้. สถานะนี้มีประโยชน์สำหรับกรณีที่กระบวนการหลักต้องการทราบโค้ดส่งคืนของเด็ก เช่น โดยปกติแล้ว 0 จะส่งสัญญาณถึงความสำเร็จและ 1 ข้อผิดพลาด แต่โปรแกรมเมอร์สามารถออกโค้ดเอาต์พุตเพิ่มเติมเพื่อส่งสัญญาณถึงปัญหาที่แตกต่างกันได้ เมื่อกระบวนการหลักสิ้นสุดลง ระบบจะทำการเรียกระบบครั้งสุดท้าย เช่น รอ () เพื่อรอให้กระบวนการย่อยยุติและส่งสัญญาณไปยังระบบปฏิบัติการว่าสามารถล้างข้อมูลใดๆ ที่เกี่ยวข้องกับกระบวนการที่ยุติได้

ประเด็นสำคัญของการบรรยาย:

● กระบวนการ — นามธรรมหลักของโปรแกรมที่ทำงานอยู่ในระบบปฏิบัติการ ในช่วงเวลาใดก็ตาม กระบวนการสามารถอธิบายได้จากสถานะของกระบวนการ: เนื้อหาของหน่วยความจำในพื้นที่ที่อยู่ เนื้อหาของการลงทะเบียนตัวประมวลผล รวมถึงตัวชี้คำสั่งและตัวชี้สแต็ก และข้อมูล IO เช่น ไฟล์ที่เปิดอยู่ที่กำลังอ่านหรือเขียน
● ประมวลผล API ประกอบด้วยการเรียกที่โปรแกรมสามารถดำเนินการกับกระบวนการได้ โดยทั่วไปจะเป็นการสร้าง ลบ หรือการโทรอื่นๆ
● กระบวนการอยู่ในสถานะใดสถานะหนึ่ง รวมทั้งกำลังทำงานอยู่ พร้อม หรือถูกบล็อก เหตุการณ์ต่างๆ เช่น การจัดกำหนดการ ข้อยกเว้นจากการจัดกำหนดการ หรือการรอ สามารถเปลี่ยนสถานะของกระบวนการจากที่หนึ่งไปอีกที่หนึ่งได้
● รายการกระบวนการ มีข้อมูลเกี่ยวกับกระบวนการทั้งหมดในระบบ แต่ละรายการในนั้นเรียกว่าบล็อกควบคุมกระบวนการ ซึ่งในความเป็นจริงแล้วเป็นโครงสร้างที่ประกอบด้วยข้อมูลที่จำเป็นทั้งหมดเกี่ยวกับกระบวนการเฉพาะ 

ที่มา: will.com