บทที่ 4 กระบวนการ 
(PROCESS)



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

4.1 แนวคิดของกระบวนการ (Process Concept)
ปัญหาหนึ่งในการอธิบายเกี่ยวกับ ระบบปฏิบัติการ คือ เราจะเรียกกิจกรรมของหน่วยประมวลผลกลางว่าอย่างไรดี ในระบบการทำงานแบบกลุ่มเรียกว่า job ในระบบปันส่วน เรียกว่า โปรแกรมผู้ใช้ (user program) หรือ task แม้แต่ระบบผู้ใช้คนเดียวอย่าง MS-DOS และ Macintosh ผู้ใช้เครื่องอาจให้หลาย ๆ โปรแกรมทำงานพร้อมกัน โดยโปรแกรมหนึ่งเป็นโปรแกรมโต้ตอบ (interactive) และที่เหลือเป็นแบบกลุ่ม (batch) ในตำราเล่มนี้คำว่า jobs กับ process มีความหมายเหมือนกัน

4.1.1 กระบวนการ (The Process)
เราอาจเรียกโปรแกรมที่กำลังทำงานอยู่ว่าเป็น กระบวนการ (process) การทำงานของกระบวนการต้องเป็นแบบลำดับ หรือ อีกนัยหนึ่ง ณ เวลาใด ๆ จะมีเพียงอย่างมากหนึ่งคำสั่ง ที่กำลังดำเนินการอยู่ในนามของกระบวนการนี้
กระบวนการไม่ได้หมายความเพียง โปรแกรมและการทำงาน เท่านั้น แต่รวมถึง program counter (พวก register ของ CPU) ,stack (ข้อมูลชั่วคราว) , data section (เก็บตัวแปรแบบ global)
โปรแกรมเป็นสิ่งไม่มีชีวิต (passive entity) เช่น คำสั่งที่เก็บไว้ในจานบันทึก ส่วนกระบวนการเสมือนสิ่งมีชีวิต (active entity) มี program counter ชี้บรรทัดคำสั่งที่จะทำงานต่อไป และกลุ่มของทรัพยากรที่เกี่ยวข้อง
แม้ว่าอาจมีกระบวนการ 2 กระบวนการ ทำงานบนโปรแกรมเดียวกัน ก็ยังต้องนับว่าเป็นการทำงานตามลำดับแยกกัน เป็นเรื่องปกติที่กระบวนการหลัก จะสร้างกระบวนการย่อยหลาย ๆ กระบวนการในขณะทำงาน ซึ่งจะได้อธิบายโดยละเอียดในภายหลัง
4.1.2 สถานะของกระบวนการ (Process State)
ในขณะที่แต่ละกระบวนการกำลังทำงานอยู่ จะมีการเปลี่ยนแปลงสถานะของกระบวนการเกิดขึ้น ซึ่งสถานะดังกล่าวจะถูกกำหนดขึ้นโดย กิจกรรม ณ เวลาปัจจุบันที่กระบวนการนั้นกำลังกระทำอยู่ โดยที่แต่ละกระบวนการจะตกอยู่ในสถานะใดสถานะหนึ่งจากสถานะที่จะกล่าวต่อไปนี้
- New : กระบวนการใหม่กำลังถูกสร้างขึ้น
- Running : กระบวนการกำลังทำงานตามคำสั่งในโปรแกรม 
(ในหน่วยประมวลผลกลาง)
- Waiting : กระบวนการกำลังรอคอยให้เหตุการณ์บางอย่างเกิดขึ้น เช่น รอให้การ
รับหรือส่งข้อมูลเสร็จ
- Ready : กระบวนการกำลังรอคอยที่จะเข้าใช้หน่วยประมวลผล
- Terminate : กระบวนการเสร็จสิ้นการทำงาน
มีข้อสังเกตว่าในขณะหนึ่ง ๆ จะมีเพียง 1 กระบวนการ เท่านั้นที่กำลังทำงานอยู่ แต่อาจมีหลาย กระบวนการอยู่ในสถานะพร้อม (Ready) หรือ สถานะกำลังรอคอย (waiting) เราสามารถแสดงสถานะต่าง ๆ ของกระบวนการได้ดังรูป




4.1.3 ตารางข้อมูลการประมวลผล (Process Control Block – PCB)
ระบบปฏิบัติการ แทนกระบวนการต่าง ๆ ด้วยตารางข้อมูลของกระบวนการ (PCB) หรืออาจเรียกว่า Task Control Block ซึ่งก็เป็นระเบียน หรือ ตารางข้อมูลที่ใช้เก็บข้อมูลต่าง ๆ ที่เกี่ยวข้องกับแต่ละกระบวนการโดยเฉพาะ ดังรูป


 

ข้อมูลต่าง ๆ ที่ปรากฏใน PCB มีดังต่อไปนี้
- สถานะของกระบวนการ (Process State) จะเก็บสถานะต่าง ๆ ได้แก่ new , running , waiting , ready หรือ terminate
- ตัวชี้โปรแกรม (program counter) จะเป็นตัวบอกตำแหน่งบรรทัดคำสั่งในโปรแกรมที่กระบวนการจะทำงานเป็นอันดับถัดไป
- รีจีสเตอร์ของหน่วยประมวลผล (CPU Register) จำนวนและชนิดของ Register นี้ ขึ้นอยู่กับฮาร์ดแวร์ของเครื่องนั้น ได้แก่ Accumulator Register, Index Register, Stack Pointer , General-purpose Register , Condition-Code Information เมื่อมีสัญญาณมาขัดจังหวะการทำงานของหน่วยประมวลผล ระบบต้องเก็บค่าต่าง ๆ ใน รีจีสเตอร์ เหล่านี้รวมทั้งตัวชี้โปรแกรมไว้ เพื่อให้กระบวนการสามารถกลับมาทำงานต่อ ณ จุดเดิมที่ถูกขัดจังหวะได้

 

- ข้อมูลในการจัดตารางทำงานของหน่วยประมวลผลกลาง (CPU Scheduling Information) คือ ข้อมูลเกี่ยวกับศักดิ์ (Priority) ของกระบวนการ , ตัวชี้แถวคอย , หรือตัวแปรอื่นใดในการจัดตารางการทำงาน
- สารสนเทศเกี่ยวกับการจัดการหน่วยความจำ (Memory – Management Information) ได้แก่ รีจีสเตอร์ฐาน (base register) และ รีจีสเตอร์ขอบเขต (limit register) หรือตารางแบ่งหน้า (page tables) หรือตารางส่วน (segment tables)
- ข้อมูลทางการบัญชี (Accounting Information) ได้แก่ จำนวนหน่วยประมวลผลกลาง และเวลาจริงที่ถูกใช้ไป , ข้อจำกัดด้านเวลา , เลขที่บัญชี , หมายเลขงานหรือกระบวนการ
- ข้อมูลสถานะการรับ-ส่งข้อมูล (I/O Status Information) ได้แก่ คำร้องขอรับ – ส่งข้อมูลที่ยังค้างอยู่ , อุปกรณ์รับ-ส่งข้อมูลที่กระบวนการนั้น ๆ กำลังถือครองอยู่ , รายชื่อของแฟ้มข้อมูลที่กำลังถือครองอยู่ , รายชื่อของแฟ้มข้อมูลที่กำลังใช้อยู่ เป็นต้น
PCB เปรียบเสมือนที่เก็บสารสนเทศต่าง ๆ ของแต่ละกระบวนการ


4.2 การจัดตารางของกระบวนการ (Process Scheduling)
จุดประสงค์ของการทำงานแบบ multiprogramming คือ การพยายามที่จะทำให้หน่วยประมวลผลกลางทำงานอย่างมีประสิทธิผลสูงสุด โดยจัดให้มีกระบวนการเข้าไปทำงานในหน่วยประมวลผลตลอดเวลา แต่สำหรับระบบที่มีหน่วยประมวลผลเดียว (Uniprocessor system) จะมีเพียง 1 กระบวนการเท่านั้นที่สามารถใช้หน่วยประมวลผลกลางได้ และในกรณีที่มีหลายกระบวนการต้องการเข้าใช้หน่วยประมวลผลกลาง งานเหล่านั้นต้องรอจนกว่าหน่วยประมวลผลกลางจะว่างลง แล้วจึงมีการจัดตารางการใช้หน่วยประมวลผลกลางใหม่อีกครั้ง

4.2.1 การจัดตารางแถวคอย (Scheduling Queue)
เมื่อกระบวนการเข้าสู่ระบบ กระบวนการจะถูกจัดให้อยู่ในแถวคอย (Job Queue) ในหน่วยเก็บข้อมูลขนาดใหญ่ (เช่น จานบันทึก) เมื่อกระบวนการได้เข้าสู่หน่วยความจำหลักแล้ว กระบวนการนั้นจะถูกเก็บในรายการแบบเชื่องโยง (Link List) ที่เรียกว่า แถวพร้อม (Ready Queue) ซึ่งกระบวนการภายในแถวพร้อมนี้เป็นกระบวนการที่อยู่ในหน่วยความจำหลัก และพร้อมที่จะทำงาน เพียงแค่กำลังรอคอยเพื่อที่จะเข้าใช้หน่วยประมวลผลกลางเพื่อทำงานต่อไป โดยที่แถวพร้อมจะเก็บตัวชี้ (Pointer) ที่ชี้ไปยัง ตารางข้อมูลของกระบวนการ (PCB) ของกระบวนการแรกและกระบวนการสุดท้ายในแถวพร้อม และในแต่ละ PCB ก็จะมีตัวชี้ไปยัง PCB ที่อยู่ถัดไปด้วย
เมื่อกระบวนการได้ใช้หน่วยประมวลผลกลาง และทำงานไปได้ระยะเวลาหนึ่ง กระบวนการนั้นอาจต้องหยุดทำงานเพราะงานเสร็จหรือ หยุดรอเหตุการณ์บางอย่างให้เกิดขึ้น เช่น รออุปกรณ์รับ-ส่งข้อมูล เนื่องจากมีกระบวนการหลายกระบวนการทำงานอยู่ในระบบ ดังนั้นกระบวนการทั้งหลายอาจต้องเข้าแถวคอยเพื่อที่จะใช้อุปกรณ์รับ-ส่งข้อมูลต่าง ๆซึ่งแถวคอย อุปกรณ์ดังกล่าว เรียกว่า “แถวอุปกรณ์” (Device Queue) โดยอุปกรณ์แต่ละตัวจะมีแถวคอยเป็นของตัวเอง ดังรูป

 


ในกรณีที่อุปกรณ์ตัวนั้นเป็นอุปกรณ์ที่ใช้เฉพาะงานใดงานหนึ่ง เช่น เครื่องขับเทป แถวคอยของอุปกรณ์ตัวนั้นก็จะมีเพียง 1 กระบวนการเท่านั้น แต่ถ้าเป็นอุปกรณ์ที่สามารถใช้ร่วมกันได้ เช่น จานบันทึกภายในแถวคอยของอุปกรณ์ตัวนั้นก็อาจมีหลายกระบวนการคอยอยู่ได้
รูปถัดไป แสดง “แผนภาพของแถวคอย” (Queuing Diagram) รูปสี่เหลี่ยมผืนผ้าแทน แถวคอย 2 แบบ คือ แถวพร้อมและแถวอุปกรณ์ วงกลมแทนทรัพยากรซึ่งเป็นเจ้าของแถวคอยนั้น ๆ เส้นลูกศรแสดงทิศทางการไหลของกระบวนการในระบบ

 

 

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

4.2.2 ตัวจัดตารางการทำงาน (Schedulers)
กระบวนการหนึ่ง ๆ จะถูกย้ายจากแถวคอยหนึ่งไปยังอีกแถวคอยหนึ่งอยู่ตลอดเวลาที่กระบวนการนั้นทำงานอยู่ ซึ่งระบบปฏิบัติการจะเป็นผู้เลือกกระบวนการจากแถวคอยแต่ละแถวออกมา โดยการเลือกกระบวนการออกมานั้นจะกระทำโดยตัวจัดตาราง (Scheduler) ที่เหมาะสม
- ตัวจัดตารางระยะยาว (Long-Term Scheduler) ทำหน้าที่เลือกกระบวนการจากหน่วยเก็บข้อมูล เพื่อนำเข้าสู่หน่วยความจำหลัก 
- ตัวจัดตารางระยะสั้น (Short-Term Scheduler หรือ CPU Scheduler) ทำหน้าที่เลือกกระบวนการที่รออยู่ในแถวพร้อมขึ้นมาเพื่อเข้าใช้หน่วยประมวลผลกลางต่อไป
ตัวจัดตารางการทำงานทั้งสองแบบมีข้อแตกต่างหลัก ๆ คือ ความถี่ในการทำงาน ตัวจัดตารางระยะสั้นจะต้องทำงานเลือกกระบวนการค่อนข้างบ่อย เพราะกระบวนการอาจทำงานในหน่วยประมวลผลกลางเพียง 2-3 มิลลิวินาที แล้วหยุดค่อยการรับส่งข้อมูล โดยปกติตัวจัดตารางระยะสั้นนี้จะทำงานอย่างน้อยทุก ๆ 10 มิลลิวินาที ซึ่งนับว่าบ่อยมาก ดังนั้นตัวจัดตารางระยะสั้นต้องสามารถทำงานได้เร็วมาก
ในส่วนของตัวจัดตารางระยะยาว จะมีความถี่ในการทำงานน้อยมาก ที่เป็นเช่นนี้เพราะว่า การสร้างกระบวนการใหม่ให้แก่ระบบอาจใช้เวลาเป็นนาที และเนื่องจากตัวจัดตารางระยะยาวเป็นตัวควบคุมจำนวนกระบลวนการที่เข้าสู่ระบบ ดังนั้นถ้าจำนวนกระบวนการที่ทำงานขนานกันในระบบมีเป็นจำนวนคงที่นั่นหมายความว่า ค่าเฉลี่ยในการสร้างกระบวนการหรือนำกระบวนการเข้าสู่หน่วยความจำหลักของระบบจะเท่ากับค่าเฉลี่ยของงานที่ออกจากระบบ ด้วยเหตุนี้ตัวจัดการทำงานจะทำงานก็ต่อเมื่อมีกระบวนการออกจากระบบ ซึ่งนับเป็นช่วงเวลาที่ยาวนาน ดังนั้นตัวจัดตารางระยะยาวก็จะมีเวลาในการตัดสินใจเลือกกระบวนการเป็นเวลานานด้วย
ข้อสำคัญที่สุดของตัวจัดตารางระยะยาวก็คือ จะเป็นผู้ทีเลือกกระบวนการให้เข้าสู่ระบบ โดยการเลือกดังกล่าวจะต้องก่อให้เกิดการทำงานอย่างสมดุลขึ้นในระบบ หมายความว่า ในระบบจะต้องมีจำนวนกระบวนการที่ใช้เวลาส่วนใหญ่ทำงานกับหน่วยประมวลผลกลาง (CPU-Bound Job) และจำนวนกระบวนการที่ใช้เวลาส่วนใหญ่ทำงานกับอุปกรณ์รับ-ส่งข้อมูล (I/O-bound job) เป็นไปอย่างเหมาะสม (สมดุลกัน)
ระบบปฏิบัติการบางระบบ (เช่น time-sharing) อาจจะมีการจัดตารางการทำงานในระดับกลางเพิ่มขึ้นอีกเรียกว่า ตัวจัดตารางระยะกลาง (Medium-term scheduler) ดังแสดงได้ดังภาพ



ตัวจัดตารางระยะกลาง จะทำหน้าที่ย้ายกระบวนการออกจากหน่วยความจำหลัก เพื่อที่จะลดจำนวนกระบวนการที่มีมากเกินไปในหน่วยความจำ (ลด Degree of Multiprogramming) ทำให้หน่วยประมวลผลทำงานได้ดีขึ้น สำหรับกระบวนการที่ถูกย้ายออกไปนี้จะถูกนำกลับเข้ามาในหน่วยความจำใหม่อีก เมื่อถึงเวลาที่เหมาะสม โดยจะเริ่มทำงานต่อจากจุดที่ออกไปจากระบบ วิธีการเคลื่อนย้ายกระบวนการดังกล่าวนี้เรียกว่า วิธีการย้ายที่ (swapping) ช่วยให้ระบบสามารถปรับสัดส่วนของกระบวนการแต่ละแบบให้เหมาะสม (Process mix) หรือช่วยลดความต้องการใช้หน่วยความจำหลักลงบ้าง

4.2.3 การเปลี่ยนงาน (Context Switch)
การเปลี่ยนกระบวนการที่ทำงานในหน่วยประมวลผล จากกระบวนการหนึ่งไปเป็นอีกกระบวนการหนึ่ง จำเป็นต้องเก็บค่าสถานะของกระบวนการเดิม และนำเอาค่าสถานะของกระบวนการใหม่มาลง (มักเป็น register) การทำเช่นนี้เรียกว่า การเปลี่ยนงาน (Context Switch) 
ระบบของการเปลี่ยนงานนี้ต้องเสียค่าใช้จ่ายสูง และยังใช้เวลาส่วนใหญ่ไปกับการ switch ซึ่งเวลาที่ใช้จะขึ้นอยู่กับฮาร์ดแวร์ที่ใช้

4.3 การดำเนินงานของกระบวนการ (Operations on Process)
4.3.1 การสร้างกระบวนการ (Process Creation)
กระบวนการหนึ่ง ๆ อาจสร้างกระบวนการใหม่เกิดขึ้น โดยการใช้คำสั่งเรียกระบบสร้างกระบวนการ และกระบวนการใหม่ ๆ ที่เกิดขึ้นมานั้นอาจจะสร้างกระบวนการใหม่ ๆ ต่อไปได้อีก ดังรูป

 

 

กระบวนการที่เป็นผู้สร้าง เรียกว่า กระบวนการแม่ (Parent Process) กระบวนการใหม่ที่ถูกสร้างขึ้นมาเรียกว่า กระบวนการลูก (Children Process) โดยทั่วไป กระบวนการหนึ่ง ๆ จะต้องการทรัพยากร เช่น เวลาที่ใช้ในหน่วยประมวลผลกลาง , หน่วยความจำ , แฟ้มข้อมูล ,อุปกรณ์รับ-ส่งข้อมูล เป็นจำนวนที่แน่นอน เพื่อที่จะทำงานได้จนเสร็จสมบูรณ์ และเมื่อมีกระบวนการย่อยเกิดขึ้น กระบวนการย่อยนั้นอาจร้องขอทรัพยากร ที่ต้องการจากระบบปฏิบัติการได้โดยตรง หรือ ถูกจำกัดให้ใช้ได้เฉพาะทรัพยากรส่วนของทรัพยากรแม่เท่านั้น ดังนั้น กระบวนการแม่ต้องแบ่งทรัพยากรให้กระบวนการย่อยแต่ละตัว หรือ ให้กระบวนการย่อยเหล่านั้น ใช้ทรัพยากรร่วมกัน (เช่น แฟ้มข้อมูล หรือ หน่วยความจำ) หรือ ให้กระบวนการย่อยใช้ทรัพยากรส่วนเฉพาะของแม่ (ซึ่งเป็นการป้องกันไม่ให้ระบบถูกแย่งทรัพยากรไปทั้งหมด เนื่องจากมีบางกระบวนการสร้างกระบวนการย่อยจำนวนมากเกินไป)
หลังจากสร้างกระบวนการย่อยแล้ว กระบวนการแม่อาจทำงาน (execute) ได้ 2 วิธี คือ
- กระบวนการแม่ ทำงานพร้อม ๆ กัน (concurrent) ไปกับกระบวนการลูก 
- กระบวนการแม่คอยจนกระทั่ง กระบวนการลูกทั้งหมด สิ้นสุดการทำงาน
ในการระบุพื้นที่ว่างของกระบวนการใหม่ทำได้ 2 วิธี คือ
- กระบวนการลูกทำสำเนา (duplicate) มาจากกระบวนการแม่ (จำลองมา)
- กระบวนการลูกมีโปรแกรมที่ถูก load เข้ามาเอง (สร้างเอง)
ในระบบปฏิบัติการ UNIX แต่ละกระบวนการจะมีเลขประจำตัวเฉพาะ (Process Identifier) เป็นเลขจำนวนเต็ม (Integer) กระบวนการจะสร้างกระบวนการย่อย โดยคำสั่งเรียกระบบ fork กระบวนการใหม่ที่เกิดขึ้น จะมีตำแหน่งโปรแกรมของกระบวนการเดิม ซึ่งช่วยให้กระบวนการแม่(เดิม) สามารถติดต่อสื่อสารกับกระบวนการลูก (ใหม่) ได้สะดวก กระบวนการทั้งสอง (แม่และลูก) จะทำงานจากคำสั่ง (ในโปรแกรมเดียวกัน) จากคำสั่ง fork โดยที่กระบวนการลูกจะได้รหัสส่งคืนจากคำสั่ง fork เป็นศูนย์ แต่กระบวนการแม่จะได้ รหัสส่งคืนเป็นตัวเลข แสดงหมายเลขของกระบวนการลูก
โดยปกติ คำสั่งหลักจากคำสั่ง fork จะเป็นคำสั่งเรียกระบบ execve ทำหน้าที่นำโปรแกรมจากจานบันทึกมาลงในหน่วยความจำทับโปรแกรมเดิมของกระบวนการที่ใช้คำสั่งนี้ แล้วทำงานต่อในโปรแกรมใหม่ กระบวนการแม่สามารถสร้างลูกได้เรื่อย ๆ หรือถ้าไม่มีอะไรทำในขณะลูกกำลังทำงาน มันจะใช้คำสั่งเรียกระบบ wait เพื่อย้ายตัวเองไปที่แถวพร้อม จนกระทั้งลูกเสร็จสิ้นการทำงาน

4.3.2 การเสร็จสิ้นกระบวนการ (Process Termination)
กระบวนการจะสิ้นสุดหรือถูกยกเลิก เมื่อทำงานเสร็จในขั้นสุดท้าย แล้วร้องขอให้ระบบปฏิบัติการลบกระบวนการทิ้งไป โดยใช้คำสั่งเรียกระบบ exit ซึ่งกระบวนสามารถส่งข้อมูล (output) กลับไปให้กระบวนการแม่ได้ โดยคำสั่งเรียกระบบ wait กระบวนการหนึ่งอาจยกเลิกกระบวนการอื่นได้ โดยใช้คำสั่งเรียกระบบ เช่น คำสั่งยกเลิก (abort) การใช้คำสั่งนี้โดยปกติ ต้องเป็นกระบวนการแม่ใช้กับกระบวนการลูกเท่านั้น (เพราะกระบวนการแม่ทราบหมายเลขของกระบวนการลูกจากเมื่อตอนที่สร้างกระบวนการลูก)
กระบวนการแม่อาจต้องการยกเลิกกระบวนการลูกตัวหนึ่งเพราะ
- กระบวนการลูกใช้ทรัพยากรที่กระบวนการแม่แบ่งให้จนหมดแล้ว ทรัพยากรไม่พอใช้
- กระบวนการแม่ไม่ต้องการใช้กระบวนการลูกตัวนี้ อีกต่อไป
- กระบวนการแม่เสร็จสิ้นและระบบปฏิบัติการไม่ต้องการให้กระบวนการลูกทำงานต่อ
ระบบส่วนใหญ่ เมื่อกระบวนการแม่สิ้นสุด กระบวนการลูกต้องสิ้นสุดด้วย เราเรียกว่า การยกเลิกแบบลูกโซ่ (Cascading Termination) ซึ่งระบบมักจะเป็นผู้จัดการ ตัวอย่าง ในระบบ UNIX กระบวนการลูกจะสิ้นสุดหรือถูกยกเลิก โดยใช้คำสั่งเรียกระบบ exit ซึ่งกระบวนการแม่จะรอเหตุการณ์นี้ โดยใช้คำสั่งเรียกระบบ wait ซึ่งจะให้ค่ากลับคืนมาเป็นหมายเลขของกระบวนการลูกที่ถูกยกเลิกไป ในระบบ UNIX กระบวนการแม่ไม่จำเป็นต้องแบ่งทรัพยากรให้กระบวนการลูกเลย ระบบจะจัดการให้โดยให้ศักดิ์เท่า ๆ กัน ทุกกระบวนการในการใช้ทรัพยากรในระบบ (เช่น หน่วยความจำหลัก , จานบันทึก)

4.4 การทำงานร่วมกันของกระบวนการ (Cooperating Processes) 
กระบวนการที่ทำงานในระบบปฏิบัติการอาจจะเป็นกระบวนการอิสระ (independent processes) หรือ กระบวนการที่ต้องทำงานร่วมกัน (cooperation processes)
- กระบวนการอิสระ คือ กระบวนการที่ไม่มีผลกระทบต่อกระบวนการอื่นในระบบ เช่น กระบวนการซึ่งไม่แบ่งข้อมูล (ชั่วคราวหรือถาวร) ให้กับกระบวนการอื่น
- กระบวนการที่ต้องทำงานร่วมกัน คือ กระบวนการที่มีผลกระทบต่อกระบวนการอื่นในระบบ เช่น กระบวนการที่ต้องแบ่งข้อมูลให้กับกระบวนการอื่น ที่เป็นกระบวนการร่วม
เหตุผลต่าง ๆ ที่ทำให้ต้องจัดเตรียมสิ่งแวดล้อมให้กับกระบวนการที่ต้องทำงานร่วมกัน คือ
1. การร่วมกันใช้ข้อมูลข่าวสาร (Information sharing) เมื่อผู้ใช้หลายคนสนใจข่าวสารชิ้นเดียวกัน (เช่น ไฟล์ที่ถูก shared) เราต้องจัดเตรียมสิ่งแวดล้อมโดยอนุญาตให้เข้าถึงทรัพยากรเหล่านี้ร่วมกันได้
2. การคำนวณรวดเร็วขึ้น (Computation Speedup) ถ้าเราต้องการให้งานปกติสามารถทำงานได้เร็วขึ้น เราจะต้องแตกงานนั้นเป็นส่วนย่อย ๆ แล้วให้แต่ละส่วนทำงานขนานกันไปแต่ความเร็วในการคำนวณจะสูงขึ้นได้ก็ต่อเมื่อ ระบบมีอุปกรณ์ที่ใช้คำนวณหลาย ๆ ตัว เช่น มี CPU หลาย ๆ ตัว หรือ มีหน่วยคำนวณหลาย ๆ ตัว
3. ระบบย่อย (Modularity) เราอาจต้องการที่จะสร้างระบบให้อยู่ในรูปของระบบย่อยหรือโมดูล โดยอาจแบ่งหน้าที่งานต่าง ๆ ของระบบไปเป็นหน้าที่ละ 1 กระบวนการ
4. ความสะดวกสบาย (Convenience) ผู้ใช้แต่ละคนอาจจะมีงานหลาย ๆ งานที่ต้องทำงานในเวลาเดียวกัน เช่น ต้องการแก้ไขข้อมูล พิมพ์ข้อมูล และแปลภาษาไปพร้อม ๆ กัน ซึ่งสามารถทำได้
เพื่อให้เห็นถึงแนวคิดของการทำงานร่วมกันของกระบวนการ ลองพิจารณาปัญหา ผู้ผลิต-ผู้ใช้ (producer – consumer) กระบวนการผู้ผลิตจะผลิตหรือสร้างข้อมูลให้กระบวนการผู้ใช้ได้ใช้งาน เช่น โปรแกรมสำหรับพิมพ์ข้อมูล จะส่งข้อมูลไปยังเครื่องพิมพ์ (นับเป็นกระบวนการผู้ผลิต) ส่วนผู้ใช้ ก็คือ ตัวควบคุมเครื่องพิมพ์ (Printer driver) ซึ่งจะเป็นผู้พิมพ์ตัวอักขระที่ส่งมา ออกทางเครื่องพิมพ์อีกทอดหนึ่ง หรือ ตัวแปลภาษาชั้นสูง จะผลิตโปรแกรมภาษา assembly ให้ compiler นำไปใช้ต่อในการผลิตโปรแกรมภาษาเครื่อง ซึ่งจะถูกตัวนำโปรแกรมลงหน่วยความจำ (Loader) บรรจุโปรแกรมนี้ลงในหน่วยความจำอีกต่อหนึ่ง
เพื่อที่จะให้กระบวนการผู้ผลิต-ผู้ใช้ สามารถทำงานขนานกันไปได้ จำเป็นต้องมีที่พักข้อมูล (Buffer) ซึ่งผู้ผลิตจะนำข้อมูลไปใส่และผู้ใช้จะดึงข้อมูลไปใช้ ขณะที่ผู้ผลิตจะผลิตข้อมูลใส่ลงในช่องว่างหนึ่งของที่พักข้อมูล ผู้ใช้ก็สามารถดึงข้อมูล จากอีกช่องหนึ่งในที่พักข้อมูลนี้ไปใช้ได้ (ในเวลาเหลื่อมกัน) ดังนั้นจึงต้องมีการประสานงานระหว่างผู้ใช้และผู้ผลิต เพื่อป้องกันผู้ผลิตใส่ข้อมูล ลงในที่พักข้อมูลที่เต็มแล้ว หรือผู้ใช้พยายามดึงข้อมูลจากที่พัก ทั้ง ๆ ที่ยังไม่มีข้อมูลอยู่ ทั้งสองกรณีนี้ผู้ผลิต หรือผู้ใช้ จะต้องรอคอย
ถ้าที่พักข้อมูลมีขนาดไม่จำกัด (Unbounded-buffer) ผู้ใช้อาจต้องคอย ถ้าที่พักว่าง แต่ผู้ผลิตสามารถผลิตข้อมูลได้ตลอดเวลา (ไม่มีวันเต็ม) 
แต่ถ้าที่พักข้อมูลมีขนาดจำกัด (Bounded-buffer) ผู้ผลิตอาจต้องรอบ้าง ถ้าที่พักข้อมูลเต็ม
ในการแก้ปัญหาดังกล่าว ควรใช้วิธีแบ่งกันใช้หน่วยความจำ (share memory) โดยกระบวนการของผู้ผลิตและผู้ใช้ share ตัวแปรเหล่านี้ร่วมกัน
var n;
type item = … ;
var buffer: array [0..n-1] of item;
in,out: 0..n-1;
- เริ่มต้น ตัวแปร in และ out มีค่าเป็น 0 in , out มีค่าตั้งแต่ 0 ถึง n – 1 
- ที่พักข้อมูลนี้เป็นแบบแถวลำดับวงกลม (Circular array) 
- มีตัวชี้ in ชี้ช่องว่างต่อจากหางแถวของที่พักข้อมูล 
- out เป็นตัวชี้ช่องที่มีข้อมูลส่วนหัวแถวของที่พักข้อมูล
ดังนั้นที่พักนี้จะว่างเมื่อ in = out และจะเต็มเมื่อ (in + 1) MOD n = out

repeat
… แสดงว่าเต็ม
produce an item in nextp
…
while (in + 1) mod n = out do no-op; // ไม่ทำอะไร
buffer[in] := nextp;
in := (in + 1) mod n; // แสดงว่าว่าง
until false;

โปรแกรมข้างต้นเป็นของผู้ผลิต มี nextp เป็นตัวแปรภายใน (local variable) ใช้เก็บข้อมูลที่ผลิตได้ก่อนที่จะนำลงที่พักข้อมูลต่อไป no-op (No-operation) คือ ประโยคว่างไม่ได้ทำอะไร
โปรแกรมต่อไปนี้ เป็นของผู้ใช้ มี nextc เป็นตัวแปรภายใน ใช้เก็บข้อมูลที่ได้จากที่พักข้อมูลร่วม ก่อนนำไปใช้งานจริง
ที่พักข้อมูลว่าง
repeat
while in = out do no-op;
nextc := buffer[out];
out := (out + 1) mod n; // ขณะที่เต็ม
…
consume the item in nextc
…
until false;

สังเกตว่า โปรแกรมนี้สามารถเก็บข้อมูลในที่พักได้มากที่สุด n – 1 เท่านั้น

4.6 การสื่อสารระหว่างกระบวนการ (Interprocess Communication IPC)
IPC จัดเตรียมกลไกลในการให้กระบวนการติดต่อสื่อสารและประสานงาน (synchronize) กับกิจกรรมต่าง ๆ ของกระบวนการ ระบบข้อความ (message system) เป็นระบบที่ดีที่สุดในการสนับสนุนการสื่อสารระหว่างกระบวนการ

4.6.1 โครงสร้างพื้นฐาน (Basic Structure)
ระบบข่าวสาร คือ ระบบติดต่อสื่อสารของกระบวนการที่ไม่จำเป็นต้องใช้ตัวแปรร่วม (share variable) IPC แบ่งการทำงานออกเป็น 2 ส่วน คือ 
- send (message) 
- receive (message)
ถ้ากระบวนการ p และ q ต้องการติดต่อสื่อสารกัน ต้องส่งและรับข้อความซึ่งกันและกันผ่าน communication link
การ Link ทำได้หลายวิธี เช่น
- ทาง physical เช่น ผ่านหน่วยความจำร่วม (share memory) , hardware bus หรือ เครือข่าย (network)
- ทาง logical เช่น ผ่านทางคุณสมบัติต่าง ๆ ทางตรรกะ (logical properties)
ปัญหาของการสร้าง (implement) link คือ
- จะสร้าง link ได้อย่างไร
- เอา link มาใช้กับกระบวนการมากกว่า 2 กระบวนการได้หรือไม่
- ต้องมี link จำนวนเท่าไร ระหว่างทุก ๆ คู่ของกระบวนการ
- ความจุของ link ควรเป็นเท่าใด หมายถึง link ต้องการพื้นที่ว่างของที่พักข้อมูลมากแค่ไหน
- ขนาดของข้อความ ควรเป็นเท่าใด แล้ว link ต้องรองรับข้อความแบบขนาดแปรผัน (variable-size) หรือ ขนาดคงที่ (fixed-sized)
- Link นั้นเป็นแบบทางเดียว (unidirectional) หรือ สองทาง (bidirectional)
ในเรื่อง unidirectional คือ กระบวนการแต่ละกระบวนการที่ link กัน ต้องทำหน้าที่ รับหรือส่งเท่านั้น แต่ทั้งรับและส่งพร้อมกันไม่ได้
การรับหรือส่ง และการใช้ link ในทาง logical มีหลายวิธีดังนี้
- การติดต่อสื่อสารทางตรงหรือทางอ้อม
- การสื่อสารนั้นเป็นแบบ symmetric หรือ asymmetric
- ที่พักข้อมูลเป็นแบบอัตโนมัติหรือแบบชัดเจนแน่นอน (explicit)
- ส่งโดยการคัดลอก (copy) หรือ ส่งโดยการอ้างอิง (reference)
- ข้อความเป็นแบบขนาดคงที่ (fixed-sized) หรือ แบบแปรผัน (variable-sized)

4.6.2 การตั้งชื่อ (Naming)
กระบวนการที่จะติดต่อสื่อสารกัน จำเป็นต้องอ้างถึง ชื่อของผู้รับ และผู้ส่ง การอ้างอิงนี้จะทำโดยตรงหรือโดยอ้อม ก็ได้
4.6.2.1 การสื่อสารโดยตรง (Direct Communication)
ในการสื่อสารโดยตรง กระบวนการที่จะส่งหรือรับข้อความ ต้องระบุ ชื่อผู้รับและผู้ส่งให้ชัดเจน โดยใช้คำสั่ง
send (P ,message) เพื่อส่งข้อความไปยังกระบวนการ P (send to P)
receive (Q, message) เพื่อรับข้อความจากกระบวนการ Q (receive from Q)
Link ในระบบนี้จะมีคุณสมบัติ คือ
- Link จะเกิดขึ้นโดยอัตโนมัติ ระหว่างกระบวนการทั้งสอง โดยที่ แต่ละกระบวนการต้องรู้ชื่อของ อีกกระบวนการหนึ่งด้วย
- Link 1 Link จะเชื่อมต่อระหว่าง 2 กระบวนการเท่านั้น
- Link อาจเป็นแบบทางเดียว แต่โดยปกติมักเป็นแบบ 2 ทาง
ตัวอย่างในปัญหา ผู้ผลิต-ผู้ใช้ (producer-consumer) เราอาจเขียนโปรแกรม สำหรับผู้ผลิตได้ดังนี้
repeat
…
produce an item in nextp
…
send (consumer, nextp);
until false;

และโปรแกรมสำหรับผู้ใช้ ดังนี้
repeat
receive (producer , nextc);
…
consume the item in nextc
…
until false;
4.6.2.2 การสื่อสารทางอ้อม (Indirect Communication)
ข้อความถูกส่งและรับจากกล่องรับจดหมาย (mailboxes) (หมายถึง port) กล่องรับจดหมายเปรียบเหมือนที่ที่กระบวนการใช้ส่งข้อความหรือลบข้อความ กล่องแต่ละกล่องจะมีเลขเฉพาะ (unique identification) ของใครของมัน กระบวนการหนึ่ง ๆ สามารถสื่อสารกับกระบวนการอื่น ๆ ได้โดยผ่านหมายเลขที่ต่างกันของกล่องรับจดหมาย กระบวนการ 2 กระบวนการติดต่อสื่อสารกันได้ถ้ามีกล่องรับจดหมายร่วมกัน (share mailbox)
คุณสมบัติของ Link คือ
- Link จะเกิดขึ้นได้ก็ต่อเมื่อ กระบวนการมีการร่วมกันใช้กล่องรับจดหมาย
- Link อาจจะเกี่ยวข้อง (associated) กับกระบวนการหลายกระบวนการ
- กระบวนการแต่ละคู่สามารถมี link ได้หลายตัว โดย link แต่ละตัวติดต่อกันผ่านทางกล่องรับจดหมาย 1 กล่อง
- Link อาจเป็นแบบทางเดียวหรือสองทาง
สมมติว่ากระบวนการ P1 , P2 และ P3 ใช้กล่องรับจดหมาย A ร่วมกัน P1 ส่งข้อความให้ A ในขณะที่ P2 และ P3 รับจาก A กระบวนการไหนจะได้รับข้อความที่ส่งมาจาก P1 คำถามนี้มีวิธีแก้หลายทางดังนี้
- อนุญาตให้ link ที่เกี่ยวข้องกันอย่างมากแค่ 2 กระบวนการ
- อนุญาตให้ระบบเลือกว่ากระบวนการไหนจะรับข้อความ (ไม่ P2 ก็ P3 จะรับข้อความ) ระบบจะเป็นผู้จำแนกผู้รับกับผู้ส่งเอง
ระบบปฏิบัติการก็มีกล่องรับจดหมายเป็นของตัวเอง โดยระบบปฏิบัติการมีกลไกในการอนุญาตให้กระบวนการใช้งานกล่องรับจดหมายได้ดังนี้
- สร้างกล่องรับจดหมายใหม่
- ส่งและรับข้อความผ่านทางกล่องรับจดหมาย
- ทำลายกล่องรับจดหมาย
ตัวอย่างเช่น ถ้ากระบวนการ P สร้างกล่องรับจดหมาย A แล้วหลังจากนั้น สร้างกระบวนการใหม่ Q P และ Q อาจจะใช้กล่องรับจดหมาย A ร่วมกัน และเมื่อกระบวนการทั้งหมดทำงานเสร็จแล้ว กล่องรับจดหมายนั้นก็จะถูกทำลายโดยระบบปฏิบัติการ (เพื่อเพิ่มที่ว่างในการใช้กล่องรับจดหมายอื่น ๆ ต่อไป)

4.6.3 การพักข้อมูล (Buffering)
ความจุของ link เป็นตัวกำหนด จำนวนของข้อความซึ่งสามารถนำข้อมูลเข้าไปพักไว้อย่างชั่วคราว ซึ่งอยู่ในรูปแถว (Queue) 3 แบบ คือ
- ความจุแบบศูนย์ (Zero capacity) ความยาวของแถวเป็น 0 
นั่นคือ link ไม่มีที่ให้ข้อความพักเลย ผู้ส่งต้องรอจนกระทั่งผู้รับมารับข้อความเอง การทำงานสอดคล้องกัน (synchronization) แบบนี้เรียกว่า rendezvous
- ความจุแบบมีขอบเขต (Bounded capacity) ความยาวของแถวมีขนาดจำกัด n 
ดังนั้นจึงมีข้อความได้มากที่สุด n ข้อความที่สามมารถอยู่ในแถว (queue)
- ความจุแบบไร้ขอบเขต (Unbounded capacity) ความยาวของแถวคอยไม่จำกัด ดังนั้นจึงสามารถนำข้อความเข้าไปรอในแถวคอยได้มากผู้ส่งจึงไม่ต้องรอเลย
กรณีความจุแบบศูนย์ คือไม่มีที่พักข้อมูล ส่วนกรณีอื่นกระบวนการจะไม่รู้เลยว่าข้อความได้มาถึงปลายทางแล้วจนกว่าการส่ง (send operation) จะเสร็จ ถ้าสารสนเทศนี้สำคัญมาต่อการคำนวณ ผู้ส่งต้องสื่อสารกับผู้รับให้ชัดเจนเพื่อรับข้อความในภายหลัง ตัวอย่างเช่น สมมติว่า กระบวนการ P ส่งข้อความให้กระบวนการ Q และจะทำงานต่อได้ก็ต่อเมื่อข้อความนั้นได้รับแล้ว กระบวนการ P จะทำงานแบบเรียงลำดับ
send (Q, message);
receive (Q, message);
กระบวนการ Q ทำงาน
receive (P, message);
send (P, “acknowledgment”);
แต่ละกระบวนการ (P,Q) ถูกเรียกว่า การติดต่อสื่อสารแบบ asynchronous
ยังมีอีกหลายกรณี ที่ไม่อาจจัดลงในแบบต่าง ๆ ที่กล่าวมาแล้ว ได้แก่
- ผู้ส่งข้อความไม่ต้องรอคอยใด ๆ แต่ถ้าผู้รับไม่ได้รับข้อความ ก่อนที่ผู้ส่งจะส่งข้อความใหม่มาอีก ข้อความเดิมจะสูญหายไป
- ผู้ส่งข้อความ อาจจะรอจนกระทั่ง ได้รับคำตอบรับ วิธีประสานงานแบบนี้ สามารถนำไปใช้ ในระบบ การเรียกโปรแกรมย่อยระยะไกล (Remote Procedure Call – RPC) ได้อย่างสะดวก การเรียกโปรแกรมย่อย ในระบบที่มีหน่วยประมวลตัวเดียว เปรียบเสมือน ระบบส่งข้อความที่ผู้ส่งจะต้องรอจนผู้รับตอบรับกลับมา

4.6.4 ข้อยกเว้น (Exception Condition)
4.6.4.1 การยกเลิกกระบวนการ (Process Terminates)
ผู้รับหรือผู้ส่งอาจจะถูกยกเลิกไป (terminate) ก่อนที่ข้อความจะถูกประมวลผล จากสถานการณ์นี้เป็นการปล่อยให้ข้อความที่ยังไม่เคยถูกรับหรือถูกประมวลผลรอคอยข้อความที่ยังไม่เคยถูกส่ง เราจำแนกได้เป็น 2 กรณี ดังนี้
1. ผู้รับของกระบวนการ P อาจจะรอข้อความจากกระบวนการ Q ซึ่งถูกยกเลิกไปแล้ว ถ้าไม่ทำอะไรซักอย่าง P ก็จะถูก block ไว้ตลอดไป ในกรณีนี้ระบบอาจจะยกเลิก P หรือไม่ก็ แจ้งให้ P ทราบว่า Q ถูกยกเลิกไปแล้ว
2. กระบวนการ P อาจจะส่งข้อความไปสู่กระบวนการ Q ซึ่งถูกยกเลิกไปแล้ว ในการทำงานแบบพักข้อมูลอัตโนมัติ (automatic-buffering scheme) ห้ามทำอะไรเสี่ยง ๆ P จะยังคงทำงานต่อไป ถ้า P ต้องการรู้ว่าข้อความที่ส่งไปได้รับการประมวลผลโดย Q หรือยัง P ต้องร้องขอว่า Q ได้รับข้อความหรือยัง (acknowledgment) อย่างชัดเจน ในกรณีแบบไม่มีที่พักข้อมูล P จะถูก block ตลอดไป เช่นเดียวกับข้อ 1 คือ ระบบอาจจะยกเลิก P หรือไม่ก็ แจ้งให้ P ทราบว่า Q ถูกยกเลิกไปแล้ว

4.6.4.2 ข้อความสูญหาย (Lost Messages)
ข้อความจากกระบวนการ P ไป กระบวนการ Q อาจจะหล่นหายไประหว่างทาง ในระบบการติดต่อสื่อสารแบบเครือข่าย อันเนื่องมาจากฮาร์ดแวร์หรือสายการสื่อสารเสียหาย ในการจัดการกับปัญหานี้มีด้วยกัน 3 วิธีดังนี้
1. ระบบปฏิบัติการต้องสืบค้นการหล่นหายนี้และส่งข้อความไปใหม่อีกครั้งหนึ่ง
2. กระบวนการของผู้ส่งต้องสืบค้นการหล่นหายนี้และส่งข้อความไปใหม่อีกครั้งหนึ่ง ถ้ายังต้องการส่งอยู่
3. ระบบปฏิบัติการต้องสืบค้นการหล่นหายนี้ แล้วแจ้งให้กระบวนการของผู้ส่งทราบว่าข้อความนั้นหายไปแล้ว กระบวนการของผู้ส่งจะเป็นผู้เลือกเองว่าจะส่งไปใหม่หรือไม่
เราจะค้นพบว่าข้อความหายไปได้ด้วยการใช้ timeout

4.6.4.3 ข้อความเสียหาย (Scrambled Messages)
ข้อความที่ส่งอาจถึงมือผู้รับ แต่เสียหาย หรือ อ่านไม่รู้เรื่อง (เนื่องจาก การรบกวนในช่องทางการสื่อสาร) กรณีนี้เหมือนกับข้อความสูญหาย ระบบปฏิบัติการอาจส่งซ้ำให้ หรือแจ้งไปยังผู้ส่งว่าข้อความเสียหาย การตรวจดูว่าข้อความเสียหายหรือไม่นั้น นิยมใช้ ผลบวกรวม (Checksum), ความคล้ายคลึงกัน (parity), และ CRC

4.6.5 ตัวอย่าง ระบบปฏิบัติการ Windows NT 
NT สนับสนุนการทำงานในสภาวะหลากหลาย (multiple) หรือระบบย่อย (subsystem) ซึ่งโปรแกรมประยุกต์จะสื่อสารกันผ่านกลไกการส่งผ่านข้อความ โปรแกรมประยุกต์เหล่านั้นก็จะถือเป็น client ของ server ในระบบย่อยของ NT
ข้อความที่ผ่านไปมาใน NT ถูกเรียกว่า ตัวเรียกการดำเนินงานภายใน (Local Procedure Call Facility (LPC)) LPC ใน NT ใช้ในการสื่อสารระหว่างกระบวนการ 2 กระบวนการ ซึ่งอยู่บนเครื่องเดียวกัน client ทุกตัวที่เรียกระบบย่อยจำเป็นต้องมีช่องทางการสื่อสาร มีอยู่ 2 ช่องทาง (port) ที่ NT ใช้ คือ ช่องการติดต่อ (connection port) และช่องการสื่อสาร (communication port) ช่องการติดต่อจะเห็นทุกกระบวนการ และให้วิธีในการติดตั้งช่องทางการสื่อสาร (communication channel)
การติดต่อสื่อสารกันทำได้ดังนี้
- client เปิดช่องการติดต่อของระบบย่อย
- client ร้องขอการติดต่อ
- server สร้างช่องการสื่อสารส่วนตัวขึ้นมา 2 ช่อง และส่งคืนช่องไปให้ client 1 ช่อง
- client และ server จะใช้ช่องในการสื่อสารเพื่อส่งข้อความหรือเรียกและฟังการตอบกลับ (reply)
เทคนิคการส่งผ่านข้อความของ NT มี 3 เทคนิค ดังนี้
1. ถ้ามีข้อความขนาดเล็กจะใช้แถว (queue) ข้อความของช่อง (port) เป็นที่เก็บข้อมูลทันที และคัดลอกข้อความจากกระบวนการหนึ่งไปยังกระบวนการอื่น วิธีนี้ข้อความสามารถส่งได้ทีละ 256 ไบต์
2. ถ้า client ต้องการส่งข้อความขนาดใหญ่ ต้องส่งผ่าน section object (share memory) client ต้องตัดสินใจว่าจะติดตั้งช่องทาง (channel) เพื่อใช้ส่งข้อความขนาดใหญ่หรือไม่ ถ้า client ตัดสินใจติดตั้งก็ต้องสร้าง section object นั้น ถ้า server ตัดสินใจตอบด้วยข้อความขนาดใหญ่เช่นกัน ก็ต้องสร้างหน่วย section object ด้วย ในการใช้ section object นี้จะมีข้อความขนาดเล็ก ๆ ที่ถูกส่งซึ่งบรรจุ pointer และขนาดของ section object นั้น
3. client ร้องขอการติดต่อเพื่อขอช่องทางการติดต่อของ server และบอกว่าจะใช้ Quick LPC