Thread

Processes and Threads Traditional process One thread of control through a large, potentially sparse address space Address space may be shared with other processes (shared mem) Collection of systems resources (files, semaphores) Thread (light weight process) A flow of control through an address space Each address space can have multiple concurrent control flows Each thread has access to entire address space Potentially parallel execution, minimal state (low overheads) May need synchronization to control access to shared variables  http://lass.cs.umass.edu/~shenoy/courses/677/lectures.html 

Threads Each thread has its own stack, PC, registers Share address space, files,…  http://lass.cs.umass.edu/~shenoy/courses/677/lectures.html 

Thread เธรด หรือโปรเซสขนาดเล็ก เป็นหน่วยพื้นฐานของการเพิ่มประสิทธิภาพการ ทำงานของหน่วยประมวลผล ส่วนประกอบของ Thread หมายเลข Thread ตัวนับ : ทราบคำสั่งต่อไปที่จะเอ็กซ์ซีคิวท์ ชุดของรีจิสเตอร์ : เก็บค่าตัวแปรที่ทำงานอยู่ สแต็ก : เก็บประวัติการเอ็กซ์ซีคิวท์ แบ่งเธรดออกเป็นเธรดเพียร์ ดังนี้ ส่วนของโค้ด (code section) ส่วนของข้อมูล (data section) ทรัพยากรของระบบปฏิบัติการ (operating-system resources)

Why use Threads? Large multiprocessors need many computing entities (one per CPU) Switching between processes incurs high overhead With threads, an application can avoid per-process overheads Thread creation, deletion, switching cheaper than processes Threads have full access to address space (easy sharing) Threads can execute in parallel on multiprocessors  http://lass.cs.umass.edu/~shenoy/courses/677/lectures.html 

Why Threads? Single threaded process: blocking system calls, no parallelism Finite-state machine [event-based]: non-blocking with parallelism Multi-threaded process: blocking system calls with parallelism Threads retain the idea of sequential processes with blocking system calls, and yet achieve parallelism Software engineering perspective Applications are easier to structure as a collection of threads Each thread performs several [mostly independent] tasks CS677: Distributed OS

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

Thread ภายในโปรเซสที่ประกอบด้วย Thread จะมีการแชร์ทรัพยากรร่วมกัน ถ้า 1 โปรเซสควบคุม 1 Thread จะเรียกว่า “Single-thread” ถ้า 1 โปรเซสควบคุมหลาย thread จะเรียกว่า “Multi-thread” เช่น โปรแกรมสมัยใหม่เช่น เว็บบราวเซอร์มี thread แสดงรูปภาพ ในขณะที่อีก thread หนึ่งกำลังโหลดข้อมูลจากเน็ตเวิร์ค

Multi-threaded Clients Example : Web Browsers Browsers such as IE are multi-threaded Such browsers can display data before entire document is downloaded: performs multiple simultaneous tasks Fetch main HTML page, activate separate threads for other parts Each thread sets up a separate connection with the server Uses blocking calls Each part (gif image) fetched separately and in parallel Advantage: connections can be setup to different sources Ad server, image server, web server… CS677: Distributed OS

Multi-threaded Server Example Apache web server: pool of pre-spawned worker threads Dispatcher thread waits for requests For each request, choose an idle worker thread Worker thread uses blocking system calls to service web request CS677: Distributed OS

A multithreaded Web server Thread Usage A multithreaded Web server

Thread Usage Rough outline of code for previous slide (a) Dispatcher thread (b) Worker thread

Three ways to construct a server Thread Usage Three ways to construct a server

Implementing Threads in User Space A user-level threads package

Implementing Threads in the Kernel A threads package managed by the kernel

Hybrid Implementations Multiplexing user-level threads onto kernel- level threads

Scheduler Activations Goal – mimic functionality of kernel threads gain performance of user space threads Avoids unnecessary user/kernel transitions Kernel assigns virtual processors to each process lets runtime system allocate threads to processors Problem: Fundamental reliance on kernel (lower layer) calling procedures in user space (higher layer)

Pop-Up Threads Creation of a new thread when message arrives (a) before message arrives (b) after message arrives

Making Single-Threaded Code Multithreaded(1) Conflicts between threads over the use of a global variable

Making Single-Threaded Code Multithreaded (2) Threads can have private global variables

สถานะของ Thread Born เธรดถูกสร้างขึ้น Ready พร้อมที่จะดำเนินการ Running ได้รับการประมวลผล Dead ทำงานเสร็จหรือยกเลิก จะถูกทำลายและคืนทรัพยากรสู่ระบบ Blocked รอคอยคำสั่งหรือการทำงานจากอุปกรณ์ Waiting รอเหตุกาณ์บางอย่าง Sleeping หยุดหรือพักการทำงานไว้ขณะหนึ่ง

Thread Management Creation and deletion of threads Critical sections Static versus dynamic Critical sections Synchronization primitives: blocking, spin-lock (busy-wait) Condition variables Global thread variables Kernel versus user-level threads CS677: Distributed OS

User-level versus kernel threads Key issues: Cost of thread management More efficient in user space Ease of scheduling Flexibility: many parallel programming models and schedulers Process blocking – a potential problem CS677: Distributed OS

User-level Threads Threads managed by a threads library Kernel is unaware of presence of threads Advantages: No kernel modifications needed to support threads Efficient: creation/deletion/switches don’t need system calls Flexibility in scheduling: library can use different scheduling algorithms, can be application dependent Disadvantages Need to avoid blocking system calls [all threads block] Threads compete for one another Does not take advantage of multiprocessors [no real parallelism] CS677: Distributed OS

User-level threads CS677: Distributed OS

Kernel-level threads Kernel aware of the presence of threads Better scheduling decisions, more expensive Better for multiprocessors, more overheads for uniprocessors CS677: Distributed OS

Light-weight Processes Several LWPs per heavy-weight process User-level threads package Create/destroy threads and synchronization primitives Multithreaded applications – create multiple threads, assign threads to LWPs (one-one, many-one, many-many) Each LWP, when scheduled, searches for a runnable thread [two-level scheduling] Shared thread table: no kernel support needed When a LWP thread block on system call, switch to kernel mode and OS context switches to another LWP CS677: Distributed OS

LWP Example CS677: Distributed OS

Thread Packages Posix Threads (pthreads) Java Threads Widely used threads package Conforms to the Posix standard Sample calls: pthread_create,… Typical used in C/C++ applications Can be implemented as user-level or kernel-level or via LWPs Java Threads Native thread support built into the language Threads are scheduled by the JVM CS677: Distributed OS

การสนับสนุนของ Thread User Thread : ทำงานในส่วนของผู้ใช้และการบริหารจัดการเธรดกระทำ โดยเธรดไลบารีระดับผู้ใช้ ในระดับผู้ใช้ ไลบรารีสนับสนุนการสร้าง, จัดเวลา และจัดการ thread โดยไม่ต้องได้รับการสนับสนุนจาก kernel Kernel ไม่ต้องยุ่งเกี่ยวกับ Thread ระดับผู้ใช้ การจัดการ thread ทำในพื้นที่ของผู้ใช้ ทำให้ thread สามารถสร้าง และจัดการได้อย่างรวดเร็ว ถ้า kernel เป็น single thread แล้ว user thread นี้บล็อก system call จะเป็นเหตุให้ทุกโปรเซสถูกบล็อกตามด้วย

การสนับสนุนของ Thread เธรดไลบารี สามเธรดหลัก POSIX (Pthreads) จาวาเธรด (Java threads) วิน 32 เธรด (Win32 threads)

การสนับสนุนของ Thread Kernel Thread : ได้รับการสนับสนุนโดยตรงจากระบบปฏิบัติการ โดยจะสร้าง, จัดเวลา และจัดการ thread ภายใน Kernel เอง เนื่องจากได้รับการสนับสนุนจากระบบปฏิบัติการ เนื่องจาก kernel จัดการเกี่ยวกับ thread เอง ดังนั้น thread เกิดการ บล็อก system call จะทำให้ kernel นั้นดึง thread อื่นเข้าไปเอ็กซ์ซี คิวท์แทนได้ ปรับปรุงประสิทธิภาพการประมวลผลแบบขนานได้ดีขึ้น ระบบปฏิบัติการจดจำ user thread แต่ละตัวได้ ทำให้สามารถจัดลำดับ ความสำคัญของเธรดได้

การสนับสนุนของ Thread ทำให้ Kernel thread สร้างและจัดการได้ช้ากว่า user thread ตัวอย่าง Windows XP/2000, Solaris, Linux, Tru64 UNIX, Mac OS X

โมเดลการทำมัลติเธรด Many-to-One 1 Kernel กับหลาย User thread ถ้า thread บล็อก system call จะทำให้โปรเซสถูกบล็อกไปด้วย อาทิเช่น โซลาริสกรีนเธรด (Solaris Green Threads) จีนูพอร์ทเทเบิลเธรด (GNU Portable Threads)

Many-to-one

โมเดลการทำมัลติเธรด One-to-One 1 Kernel กับ 1 User thread ทำงานได้พร้อมกัน ยอมให้ thread อื่นรันได้เมื่อ thread บล็อก system call คำนึงถึงการสร้าง kernel และ user thread ต้องสัมพันธ์กัน การสร้าง kernel thread เป็นประสิทธิภาพของโปรแกรม อาทิเช่น วินโดวส์ (Windows) ลินุกซ์ (Linux) โซลาริส ตั้งแต่รุ่นที่ 9 เป็นต้นไป (Solaris 9 and later)

One-to-one

โมเดลการทำมัลติเธรด Many-to-many User thread มากกว่าหรือเท่ากับ Kernel thread ได้ kernel thread กำหนดแอพพลิเคชัน ยอมให้ผู้พัฒนา สร้าง user thread ได้ตามต้องการ แต่ไม่สามารถรันได้ พร้อมกัน เนื่องจาก Kernel จัดเวลาให้ครั้งละ thread

โมเดลการทำมัลติเธรด ลดข้อจำกัดของโมเดลทั้งสอง สามารถรันแบบขนานในระบบมัลติโปรเซสเซอร์ เมื่อ thread เกิดการบล็อก system call แล้ว kernel จะจัดเวลาเพื่อ นำ thread อื่นขึ้นมารันแทน อาทิเช่น โซลาริสก่อนรุ่นที่ 9 วินโดวส์ที่ใช้แพ็กเกจ เธรดไฟเบอร์ (ThreadFiber package)

Many-to-many

โมเดลการทำมัลติเธรด Two-level Model มีความแตกต่างจาก M:M ยกเว้นความสามารถในการเชื่อมระหว่างเธรด ระดับผู้ใช้กับเธรดระดับเคอร์แนลเข้าไว้ด้วยกัน อาทิเช่น IRIX HP-UX Tru64 UNIX Solaris 8 และรุ่นก่อนหน้า

Two-level model

Thread Libraries Thread library provides programmer with API for creating and managing threads Two primary ways of implementing Library entirely in user space Kernel-level library supported by the OS

การยกเลิก Thread การทำให้ thread จบการทำงานก่อนจะเสร็จสมบูรณ์ thread ที่ถูกยกเลิก เรียกว่า target thread การยกเลิกมี 2 รูปแบบ การยกเลิกแบบไม่สัมพันธ์ (Asynchronous cancellation) ทำให้ เธรดนั้นสิ้นสุดการทำงานโดยทันทีทันใด การยกเลิกแบบเชิงสัมพันธ์ (Deferred cancellation) อนุญาตให้ เธรดที่ต้องการยกเลิก ได้รับการตรวจสอบถึงความเหมาะสมว่าสามารถ ยกเลิกได้หรือไม่ก่อน อาจเกิดความยุ่งยากในการยกเลิก ภาวะทรัพยากรถูกยกเลิกขณะอัพเดท ข้อมูลที่แชร์อยู่กับ Thread อื่น

การยกเลิก Thread การยกเลิก thread จะเกิดขึ้นได้เมื่อ thread ทำงานถึงจุดที่เรียกว่า Cancellation Point pthread_testcancel() ส่วนมากระบบปฏิบัติการยอมให้ยกเลิกแบบ Asynchronous ในขณะที่ Pthread API ยอมให้ยกเลิกแบบ Deferred ด้วย

Thread-Local Storage Thread-local storage (TLS) allows each thread to have its own copy of data Useful when you do not have control over the thread creation process (i.e., when using a thread pool) Different from local variables Local variables visible only during single function invocation TLS visible across function invocations Similar to static data TLS is unique to each thread

pthreads มาตรฐาน POSIX (IEEE 1003.1c) API สำหรับการสร้างเธรด และการทำงานเชิงสัมพันธ์ API จะกำหนดพฤติกรรมของเธรดไลบรารี่ การนำไปใช้งานขึ้นอยู่กับ การพัฒนาไลบรารี่ โดยปกติมีใช้อยู่ใน ระบบปฏิบัติการยูนิกส์ (โซลาริส ลินุกซ์ แม็กโอเอส เอ็กซ์ )

Windows xp threads ใช้การแมพแบบ One-to-One แต่ละเธรดประกอบไปด้วย เธรดไอดี (thread Id) เซ็ตของรีจิสเตอร์ (Register set) แบ่งระหว่าง สแต็กของผู้ใช้กับของเคอร์แนล พื้นที่การจัดเก็บข้อมูลแบบเฉพาะตัว

Windows xp threads เซ็ตของรีจีสเตอร์ สแต็ก และ พื้นที่การจัดเก็บข้อมูลแบบไพรเวท รวมเรียกว่าคอนเท็กซ์ (context) หรือสภาพแวดล้อมของเธรด โครงสร้างข้อมูลพื้นฐานของเธรด ประกอบด้วย ETHREAD (executive thread block) KTHREAD (kernel thread block) TEB (thread environment block)

Windows xp threads

Linux threads ในระบบลีนุกซ์อ้างอิงโดยเรียกว่า ทาสค์หรืองาน แทนที่จะเรียกว่า เธรด การสร้างเธรดสามารถทำได้โดยการเรียกระบบด้วยคำสั่ง clone() คำสั่ง clone() อนุญาตให้ทาสค์ลูกสามารถร่วมใช้พื้นที่แอดเดรส หรือ แอดเดรสสเปซของทาสค์ต้นกำเนิด

Linux threads