You are on page 1of 24

บทที่ 5

เทรด
Thread

Thread 1
หัวข้อบรรยาย
 ความหมายของเทรด
 ความเหมือนกันระหว่างโปรเซสและเทรด
 ความแตกต่างระหว่างโปรเซสและเทรด
 เหตุใดจึงใช้เทรด
 ระบบปฏิบัติการและเทรด
 Kernel-Level Threads
 User-Level Threads
 Multithreading Models

Thread 2
ความหมายของเทรด
 เทรด จะเป็ นส่วนประกอบส่วนหนึ่ งของโปรเซสที่กำาลังทำาการ
ประมวลผลอย่่
 โปรเซสและเทรดมีความหมายที่แตกต่างกัน โปรเซสใช้ในการ
จัดกลุ่มทรัพยากรต่างๆเข้าด้วยกัน ส่วนเทรดนั้ นเป็ นเพียงสิ่ง
หนึ่ งที่ถ่กจัดตารางให้ทำาการประมวลผลโดยซีพีย่
 เทรดเป็ นลำาดับการประมวลผลคำาสัง ่ ที่มีอย่่ภายในโปรเซส
 เนื่ องจากเทรดนั้ นมีคุณสมบัติบางส่วนของโปรเซสอย่่ด้วย จึง
อาจเรียกได้ว่าป็ น lightweight process
 ในโปรเซสหนึ่ งอาจประกอบด้วยเทรดจำานวนมากที่กำาลัง
ประมวลผลอย่่

Thread 3
ลักษณะของ Single และ
Multithreaded Processes

Thread 4
ความหมายของเทรด (ต่อ)
 เทรดหรือ lightweight process หมายถึง หน่วยพื้ นฐาน
ของการทำางานซีพีย่ ประกอบด้วย
 รีจสเตอร์ Program counter
 รีจิสเตอร์อ่ น
ื ๆ (Register set)
 สแตก

Thread 5
ความเหมือนกันระหว่างโปร
เซสและเทรด
 โปรเซสและเทรดต่างๆใช้งานซีพย ี ่ร่วมกัน โดยมีเทรด
เพียงหนึ่ งเดียวที่กำาลังประมวลผลอย่่ โดยเทรดอื่นๆ
ต้องหยุดรอ
 เทรดต่างๆที่อย่่ภายในโปรเซสเดียวกัน จะประมวลผล
แบบเรียงตามลำาดับเหมือนกับโปรเซสต่างๆ
 เทรดหนึ่ งสามารถสร้างเทรดใหม่ข้ น ึ มาได้
 เมื่อเทรดหนึ่ งอย่่ในสถานะ blocked ก็สามารถนำาเทรด
อื่นขึ้นมาประมวลผลแทนได้

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

Thread 7
เหตุใดจึงใช้เทรด
 มีเหตุผลหลายประการที่สนั บสนุ นการใช้เทรด ดังนี้
 โปรเซสที่ประกอบด้วยหลายๆเทรดมีคุณสมบัตท ิ ่ี
เหมาะสมกับการทำาหน้าที่เป็ นเซิรฟ ์ เวอร์ เช่น เว็บ
เซิรฟ์ เวอร์
 เนื่ องจากเทรดสามารถใช้งานข้อม่ลร่วมกันได้ จึงไม่
จำาเป็ นที่จะต้องใช้ความสามารถของระบบปฏิบต ั ิการใน
เรื่องการสื่อสารระหว่างโปรเซส ซึ่งกินทรัพยากรมาก
และทำางานได้ช้า
 เทรดมีคณ ุ สมบัติพนฐานที
ื้ ่เหมาะสมกับการประมวลผล
บนเครื่องคอมพิวเตอร์ท่ีมซ ี พี ย
ี ห
่ ลายตัว
Thread 8
ระบบปฏิบัติการและเทรด
 ระบบปฏิบต ั ก
ิ ารที่สนั บสนุ นการทำางานแบบเทรด แบ่ง
ออกเป็ น 2 แนวทาง คือ
 Kernel-level thread
 User-level thread

Thread 9
ปฏิบัติการที่สนั บสนุ น User
thread

Thread 10
Kernel-Level Threads
 หมายถึง ระบบปฏิบต ั ิการที่สนั บสนุ นการทำางานของ
เทรดโดยตรง
 โปรแกรมผ้ใ่ ช้จึงสามารถเรียกใช้เทรดได้ง่าย ผ่าน
system call และในทุกครั้งที่มีการสร้างเทรดใหม่ข้ ึนมา
 ระบบปฏิบต ั ก
ิ ารก็จะสร้างเทรดของตนเองขึ้นมาสนั บสนุ
นการทำางานของเทรดใหม่น้ ั นและข้อม่ลเกี่ยวกับเทรด
นั้ นทั้งหมดจะถ่กจัดเก็บไว้ในตาราง thread table

Thread 11
User-Level Threads
 หมายถึงระบบคอมพิวเตอร์ท่ีระบบปฏิบต ั ิการไม่
สนั บสนุ นการทำางานของเทรดโดยตรง โดยที่โปรแกรม
ของผ้่ใช้จะต้องเป็ นฝ่ ายบริหารจัดการการทำางานของ
เทรดด้วยตนเองผ่านทางการใช้บริการจากฟั งก์ชันต่างๆ
ในโปรแกรมอรรถประโยชน์แทนที่จะเป็ นการใช้ system
call ที่เกิดขึ้นใน kernel-level thread
 ทำาให้ไม่เกิดอินเทอร์รพ ั ท์เพื่อเรียกเคอร์แนลขึ้นมา
ทำางาน

Thread 12
ปฏิบัติการที่ไม่สนั บสนุ น User
thread

Thread 13
Multithreading Models
 Many-to-One

 One-to-One

 Many-to-Many

Thread 14
แบบ Many-to-One
 Kernel กับหลาย User thread การจัดการ threadอย่่ใน
พื้ นที่ของผ้ใ่ ช้ซ่งึ มีประสิทธิภาพ แต่ถา้ thread บล็อก
system call จะทำาให้โปรเซสถ่กบล้อกไปด้วย

Thread 15
Many-to-One Model

Thread 16
แบบ One-to-One
 1 Kernel กับ 1 User thread ทำางานได้พร้อมกันดีกว่า
แบบแรก โดยยอมให้ thread อื่นรันได้เมื่อ thread
บล็อก system call ต้องคำานึ งการสร้าง kernel และ
user thread ต้องสัมพันธ์กน
ั การสร้าง kernel thread
เป็ นประสิทธิภาพของโปรแกรม

 ตัวอย่าง
- Windows 95/98/NT/2000
- OS/2

Thread 17
One-to-one Model

Thread 18
แบบ Many-to-Many Model
 1. User thread มากกว่าหรือเท่ากับ Kernel thread
ได้
 2. kernel thread กำาหนดแอปพลิเคชัน Many-to-One
ยอมให้ผพ ้่ ัฒนา สร้าง user thread ได้ตามต้องการ แต่ไม่
สามารถรันได้พร้อมกัน เนื่ องจาก Kernel จัดเวลาให้ครั้ง
ละ thread
 3. User thread มากว่าหรือเท่ากับ Kernel thread ก็ได้
 4. One-to-One ยอมให้รน ั พร้อมกันได้ ผ้พ
่ ัฒนาระวังอย่า
สร้าง thread มากเกินไป
 5. ลดข้อจำากัดของโมเดลทั้งสอง
Thread 19
แบบ Many-to-Many Model
(ต่อ)
 6. ผ้พ
่ ัฒนาสร้าง thread ได้เท่าที่จำาเป็ น และสัมพันธ์
กับ Kernel
 7. สามารถรันแบบขนานในระบบมัลติโปรเซสเซอร์
 8. เมื่อ thread เกิดการบล็อก system call แล้ว kernel
จะจัดเวลาเพื่อนำา thread อื่นขึ้นมารันแทน

Thread 20
Many-to-Many Model

Thread 21
แบบ Many-to-Many Model
(ต่อ)
 ระบบปฏิบต ั ก
ิ ารบางตัวพยายามที่จะเชื่อมต่อช่องว่างระหว่าง
ชนิ ดการทำางานของเทรดในร่ปแบบ Many-to-one กับ One
– to – one เข้าด้วยกันโดยนำา User-level threads กับ
Kernel-level threads มาพัฒนารวมกัน เกิดเป็ นชนิ ดการ
ทำางานของเทรดที่เรียกว่า Many-to –many ขึ้น
 หลักการทำางานคือจะ Mapping ตัว User-level threads
หลายๆตัวเข้ากับชุดของ Kernel-level threads ซึ่งในบาง
ครั้งก็จะเรียกเทคนิ คนี้ ว่า m-to-n thread mapping เนื่ องจาก
เทรดของ User-level threads และ Kernel-level threads ไม่
จำาเป็ นต้องมีจำานวนที่เท่ากัน

Thread 22
แบบ Many-to-Many Model
(ต่อ)
 การทำางานของเทรดแบบ One-to – One จะต้องให้ระบบปฏิบัติการจัดสรร
โครงสร้างข้อม่ลให้กับ Kernel-level threads แต่ละตัว จึงทำาให้ปริมาณของ
หน่วยความจำาที่สญ ่ เสียไปกับการจัดสรรโครงสร้างข้อม่ลให้กับ Kernel-
level threads ทั้งหมดกลายเป็ นเรื่องสำาคัญพอๆกับเรื่องจำานวนของเทรดที่
เพิ่มขึ้นในระบบ
 ซึ่งเรื่องเหล่านี้ จะก่อให้เกิด Overhead ขึ้นกับระบบ ดังนั้ นเพื่อลดปั ญหาดัง
กล่าวที่เกิดขึ้น การทำางานของเทรดแบบ Many-to-Many จึงพัฒนาเทคนิ ค
ที่เรียกว่า Thread pooling ขึ้น จะช่วยให้โปรเซสต่างๆสามารถระบุจำานวน
ของ Kernel-level threads ที่ต้องการได้ ตย.เช่นร่ปที่ 5 โปรเซส P1 ระบุ
การใช้งาน Kernel-level threads 3 ตัว โดย เทรด T1 และ T2 จะใช้
Kernel-level threads ตัวเดียวกัน ส่วนเทรด T3 กับเทรด T4 ใช้ Kernel-
level threads แต่ละอันแยกกันไป

Thread 23
แบบ Many-to-Many Model
(ต่อ)
 ข้อจำากัดของการทำางานของเทรดแบบ Many-to Many
คือ การออกแบบระบบปฏิบต ั ิการให้สนั บสนุ นชนิ ดการ
ทำางานของเทรดในลักษณะนี้ ค่อนข้างยุ่งยากซับซ้อน
 อีกทั้งในปั จจุบน
ั ก็ยัง ไม่มีการกำาหนดมาตรฐานสำาหรับ
ชนิ ดการทำางานของเทรดในลักษณะนี้ ขึ้นด้วย

Thread 24