Processes• Recall that a process in

Processes
• Recall that a process includes many things
• An address space (defining all the code and data pages)
• OS resources (e.g., open files) and accounting information
• Execution state (PC, SP, regs, etc.)
• Creating a new process is costly because of all of the data
structures that must be allocated and initialized
• Recall struct proc in Solaris
• …which does not even include page tables, perhaps TLB
flushing, etc.
• Communicating between processes is costly because most
communication goes through the OS
• Overhead of system calls and copying data



Parallel Programs
• To execute these programs we need to
• Create several processes that execute in parallel
• Cause each to map to the same address space to share data
• They are all part of the same computation
• Have the OS schedule these processes in parallel
• This situation is very inefficient
• Space: PCB, page tables, etc.
• Time: create data structures, fork and copy addr space, etc.
• Solutions: possible to have more efficient, yet cooperative
“processes”?


Rethinking Processes
• What is similar in these cooperating processes?
• They all share the same code and data (address space)
• They all share the same privileges
• They all share the same resources (files, sockets, etc.)
• What don’t they share?
• Each has its own execution state: PC, SP, and registers
• Key idea: Why don’t we separate the concept of a process from
its execution state?
• Process: address space, privileges, resources, etc.
• Execution state: PC, SP, registers
• Exec state also called thread of control, or thread


Threads
• Modern OSes (Mac, Windows, modern Unix) separate
the concepts of processes and threads
• The thread defines a sequential execution stream within a
process (PC, SP, registers)
• The process defines the address space and general process
attributes (everything but threads of execution)
• A thread is bound to a single process
• Processes, however, can have multiple threads
• Threads become the unit of scheduling
• Processes are now the containers in which threads execute



Analogy:
• Process:
• Hire 4 software engineers to work on 4 projects
• Thread:
• Have one engineer to work on 4 projects


The thread model
• Shared information
• Processor info: parent process, time, etc
• Memory: segments, page table, and stats, etc
• I/O and file: communication ports, directories and file descriptors, etc
• Private state
• Registers
• Program counter
• Execution stack
• State (ready, running and blocked)
• Why?
• Each thread execute separately


Kernel-Level Threads
• We have taken the execution aspect of a process and
separated it out into threads
• To make concurrency cheaper
• As such, the OS now manages threads and processes
• All thread operations are implemented in the kernel
• The OS schedules all of the threads in the system
• OS-managed threads are called kernel-level threads or
lightweight processes
• Windows: threads
• Solaris: lightweight processes (LWP)
• POSIX Threads (pthreads): PTHREAD_SCOPE_SYSTEM



Kernel-level Thread
Limitations
• Kernel-level threads make concurrency much cheaper than
processes
• Much less state to allocate and initialize
• However, for fine-grained concurrency, kernel-level threads
still suffer from too much overhead
• Thread operations still require system calls
• Ideally, want thread operations to be as fast as a procedure call
• For such fine-grained concurrency, need even “cheaper”
threads


User-Level Threads
• To make threads cheap and fast, they need to be
implemented at user level
• Kernel-level threads are managed by the OS
• User-level threads are managed entirely by the run-time system
(user-level library)
• User-level threads are small and fast
• A thread is simply represented by a PC, registers, stack, and
small thread control block (TCB)
• Creating a new thread, switching between threads, and
synchronizing threads are done via procedure call
• No kernel involvement
• User-level thread operations 100x faster than kernel threads
• pthreads: PTHREAD_SCOPE_PROCESS


User-level Thread Limitations
• But, user-level threads are not a perfect solution
• As with everything else, they are a tradeoff
• User-level threads are invisible to the OS
• They are not well integrated with the OS
• As a result, the OS can make poor decisions
• Scheduling a process with idle threads
• Blocking a process whose thread initiated an I/O, even though the
process has other threads that can execute
• Solving this requires communication between the kernel and
the user-level thread manager


Kernel- vs. User-level Threads
• Kernel-level threads
• Integrated with OS (informed scheduling)
• Slow to create, manipulate, synchronize
• User-level threads
• Fast to create, manipulate, synchronize
• Not integrated with OS (uninformed scheduling)
• Understanding the differences between kernel- and
user-level threads is important
• For programming (correctness, performance)
• For test-taking



Kernel- and User-level
Threads
• Or use both kernel- and user-level threads
• Can associate a user-level thread with a kernel-level thread
• Or, multiplex user-level threads on top of kernel-level
threads
• Java Virtual Machine (JVM)
• Java threads are user-level threads
• On older Unix, only one “kernel thread” per process
• Multiplex all Java threads on this one kernel thread
• On Windows NT, modern Unix
• Can multiplex Java threads on multiple kernel threads
• Can have more Java threads than kernel threads


Implementing Threads
• Implementing threads has a number of issues
• Interface
• Context switch
• Preemptive vs. Non-preemptive
• What do they mean?
• Scheduling
• Synchronization (next lecture)
• Focus on user-level threads
• Kernel-level threads are similar to original process
management and implementation in the OS



Sample Thread Interface
• thread_create(procedure_t, arg)
• Create a new thread of control
• Start executing procedure_t
• thread_yield()
• Voluntarily give up the processor
• thread_exit()
• Terminate the calling thread; also thread_destroy
• thread_join(target_thread)
• Suspend the execution of calling thread until target_thread
terminates



Thread Scheduling
• For user-level thread: scheduling occurs entirely in user-space
• The thread scheduler determines when a thread runs
• It uses queues to keep track of what threads are doing
• Just like the OS and processes
• But it is implemented at user-level in a library
• Run queue: Threads currently running (usually one)
• Ready queue: Threads ready to run
• Are there wait queues?



Sample Thread Interface
• thread_create(procedure_t, arg)
• Create a new thread of control
• Start executing procedure_t
• thread_yield()
• Voluntarily give up the processor
• thread_exit()
• Terminate the calling thread; also thread_destroy
• thread_join(target_thread)
• Suspend the execution of calling thread until target_thread
terminates


Thread Context Switch
• The context switch routine does all of the magic
• Saves context of the currently running thread (old_thread)
• Push all machine state onto its stack
• Restores context of the next thread
• Pop all machine state from the next thread’s stack
• The next thread becomes the current thread
• Return to caller as new thread
• This is all done in assembly language
• See arch/mips/mips/switch.S in OS161 (kernel thread
implementation)



Wait a minute
• Non-preemptive threads have to voluntarily give up
CPU
• Only voluntary calls to thread_yield(), or thread_exit()
causes a context switch
• What if one thread never release the CPU (never calls
thread_yield())?
• We need preemptive user-level thread scheduling


Preemptive Scheduling
• Preemptive scheduling causes an involuntary context switch
• Need to regain control of processor asynchronously
• How?
• Use timer interrupt
• Timer interrupt handler forces current thread to “call”
thread_yield
• How


Process vs. threads
• Multithreading is only an option for “cooperative tasks”
• Trust and sharing
• Process
• Strong isolation but poor performance
• Thread
• Good performance but share too much
• Example: web browsers
• Safari: multithreading
• one webpage can crash entire Safari
• Google Chrome: each tab has its own process


Threads Summary
• The operating system as a large multithreaded program
• Each process executes as a thread within the OS
• Multithreading is also very useful for applications
• Efficient multithreading requires fast primitives
• Processes are too heavyweight
• Solution is to separate threads from processes
• Kernel-level threads much better, but still significant overhead
• User-level threads even better, but not well integrated with OS
• Now, how do we get our threads to correctly cooperate with
each other?
• Synchronization…

ผลลัพธ์ (ไทย) 1:

กระบวนการ•นึกว่า กระบวนการประกอบด้วยสิ่งต่าง ๆ มากมาย•เป็นพื้นที่ที่อยู่ (การกำหนดรหัสและข้อมูลเพจทั้งหมด)• OS ทรัพยากร (เช่น เปิดแฟ้ม) และบัญชีข้อมูล•สถานะการดำเนินการ (PC, SP, regs ฯลฯ)•สร้างกระบวนการใหม่จะเสียค่าใช้จ่ายเนื่องจากข้อมูลทั้งหมดโครงสร้างที่ต้องปันส่วน และเริ่มต้น•เรียกคืน struct กระบวนการในโซลาริส•... .which ไม่ได้รวมตารางหน้า TLB ทีลบ ฯลฯ•ติดต่อสื่อสารระหว่างกระบวนเป็นค่าใช้จ่ายเนื่องจากส่วนใหญ่สื่อสารไปถึงระบบปฏิบัติการ•ค่าใช้จ่ายในระบบโทรศัพท์และการคัดลอกข้อมูลโปรแกรมแบบขนาน•เพื่อเรียกใช้โปรแกรมเหล่านี้เราจำเป็นต้อง•สร้างกระบวนการต่าง ๆ ที่ดำเนินการควบคู่กัน•สาเหตุแต่ละแมปที่อยู่พื้นที่เดียวกันเพื่อใช้ข้อมูลร่วมกัน•เป็นส่วนหนึ่งของการคำนวณเดียวกัน•มีระบบปฏิบัติการที่จัดกำหนดการกระบวนการเหล่านี้ควบคู่กัน•สถานการณ์นี้จะต่ำมาก•เนื้อที่: PCB ตารางหน้า ฯลฯ•เวลา: สร้างโครงสร้างข้อมูล ส้อมและคัดลอกที่อยู่พื้นที่ ฯลฯ•โซลูชั่น: จะต้องมีประสิทธิภาพมากขึ้น สหกรณ์ยัง"กระบวนการ" หรือไม่กระบวนการคิด•สิ่งคล้ายเหล่านี้ร่วมมือดำเนินการหรือไม่•พวกเขาทั้งหมดใช้รหัสและข้อมูล (พื้นที่) เหมือนกันพวกเขาทั้งหมดใช้สิทธิ์เดียวกัน••พวกเขาทั้งหมดใช้ทรัพยากรเดียวกัน (แฟ้ม ซ็อกเก็ต ฯลฯ)•ที่ไม่พวกเขาใช้ร่วมกันหรือไม่•มีสถานะการดำเนินการของตัวเอง: PC, SP และทะเบียน•คิดคีย์: ทำไมไม่เราแยกแนวความคิดของกระบวนการจากสถานะการดำเนินการหรือไม่•กระบวนการ: ว่าง สิทธิ์ ทรัพยากร และอื่น ๆ•สถานะการดำเนินการ: PC, SP ลงทะเบียน•รัฐ exec เรียกว่าเธรดของตัวควบคุม หรือหัวข้อหัวข้อ•แยก OSes สมัย (Mac, Windows, Unix สมัย)แนวคิดของกระบวนการและหัวข้อ•หัวข้อกำหนดกระแสการดำเนินการตามลำดับภายในเป็นกระบวนการ (PC, SP ลงทะเบียน)•การกำหนดพื้นที่และกระบวนการทั่วไปแอตทริบิวต์ (ทุกอย่างแต่หัวข้อของการดำเนินการ)หัวข้อ• A กับกระบวนการหนึ่ง•กระบวนการ อย่างไรก็ตาม ได้หลายหัวข้อหัวข้อ•กลายเป็น หน่วยของการวางแผน•กระบวนการก็เก็บเธรดที่เรียกใช้เปรียบเทียบ:•กระบวนการ:•จ้างวิศวกรซอฟต์แวร์ 4 การทำงานในโครงการ 4•หัวข้อ:•มีวิศวกรหนึ่งในการทำงานในโครงการ 4รูปแบบหัวข้อ•ร่วมข้อมูล•ตัวประมวลผลข้อมูล: หลักการ เวลา ฯลฯ•หน่วยความจำ: เซ็กเมนต์ หน้า โต๊ะ และสถิติ ฯลฯ• I/O และแฟ้ม: พอร์ตการสื่อสาร ไดเรกทอรี และตัวแสดงรายละเอียดแฟ้ม ฯลฯ•สถานะส่วนตัว•การลงทะเบียน•โปรแกรมเคาน์เตอร์•การดำเนินการกองซ้อน•รัฐ (พร้อม รัน และถูกบล็อค)•ทำไม•แต่ละหัวข้อปฏิบัติแยกต่างหากเธรดระดับเคอร์เนล•เรามีดำเนินการด้านการดำเนินการของกระบวนการ และแบ่งออกเป็นหัวข้อ•เพื่อทำให้เกิดราคาถูกกว่า•เช่น OS ตอนนี้จัดการหัวข้อและกระบวนการ•ดำเนินงานเธรดทั้งหมดจะดำเนินการในเคอร์เนล•ระบบปฏิบัติการที่จัดกำหนดการเธรดทั้งหมดในระบบ•จัดการ OS กระทู้เรียกว่าเธรดระดับเคอร์เนล หรือกระบวนการที่มีน้ำหนักเบา• Windows: หัวข้อ•โซลาริส: กระบวนการน้ำหนักเบา (LWP)•กระทู้ POSIX (pthreads): PTHREAD_SCOPE_SYSTEM เธรดระดับเคอร์เนลข้อจำกัดหัวข้อ•ระดับ kernel ให้เกิดมากถูกกว่ากระบวนการ•มากน้อยสถานะ การปันส่วนเริ่มต้น•อย่างไรก็ตาม สำหรับทรายแป้งละเอียดเกิด เธรดระดับเคอร์เนลยัง ต้องทนทุกข์ทรมานจากเหนือศีรษะมากเกินไป•หัวข้อการดำเนินงานยังต้องเรียกระบบ•ห้อง ต้องการหัวข้อการดำเนินงานให้รวดเร็วที่เรียกขั้นตอน•สำหรับเกิดเช่นทรายแป้งละเอียด จำเป็นแม้กระทั่ง "ถูกกว่า"หัวข้อเธรดระดับผู้ใช้•เพื่อให้กระทู้ราคา และรวดเร็ว พวกเขาจำเป็นต้องดำเนินการในระดับผู้ใช้•ระดับ kernel กระทู้จะถูกจัดการ โดยระบบปฏิบัติการ•เธรดระดับผู้ใช้จะถูกจัดการทั้งหมด โดยระบบขณะทำงาน(ระดับของผู้ใช้ไลบรารี)เธรดระดับผู้ใช้•มีขนาดเล็ก และรวดเร็วหัวข้อ• A เพียงแสดง โดยพีซี ทะเบียน กอง และหัวข้อเล็กควบคุมบล็อก (TCB)•การสร้างหัวข้อใหม่ สลับระหว่างหัวข้อ และหัวข้อให้ตรงกันเสร็จสิ้นผ่านการเรียกขั้นตอน•ไม่มีส่วนร่วมของเคอร์เนล•เธรดระดับผู้ใช้งาน 100 x เร็วกว่ากระทู้เคอร์เนล• pthreads: PTHREAD_SCOPE_PROCESS เธรดระดับผู้ใช้ข้อจำกัด•แต่ เธรดระดับผู้ใช้ไม่ได้ เพราะ•กับทุกอย่างอื่น พวกเขาเป็นยอมเธรดระดับผู้ใช้•ไม่เห็นระบบปฏิบัติการ•จะไม่ดีรวมกับระบบปฏิบัติการ•เป็นผล ระบบปฏิบัติสามารถตัดสินใจได้ดี•การ มีหัวข้อที่ไม่ได้ใช้งาน•บล็อกเธรดเริ่มต้นการ I/O ถึงแม้ว่ากระบวนการกระบวนการมีหัวข้ออื่นที่สามารถดำเนินการ•แก้นี้ต้องการสื่อสารระหว่างเคอร์เนล และเธรดระดับผู้ใช้ผู้จัดการเธรดเคอร์เนล - เทียบกับระดับผู้ใช้หัวข้อ•ระดับ kernel•รวมเข้ากับ OS (แผนทราบ)•ชะลอการสร้าง จัดการ การซิงโครไนส์•ผู้ใช้ระดับหัวข้อ•รวดเร็วสร้าง จัดการ ประสาน•ไม่รวมกับ OS (ไม่รู้วางแผน)•เข้าใจความแตกต่างระหว่างเมล็ด - และเธรดระดับผู้ใช้เป็นสำคัญ•การเขียนโปรแกรม (ความถูกต้อง ประสิทธิภาพการทำงาน)•สำหรับการทดสอบ เคอร์เนล และผู้ใช้ระดับหัวข้อ•ใช้เธรดเคอร์เนล และผู้ใช้ระดับทั้งสอง•สามารถเชื่อมโยงเธรดระดับผู้ใช้กับเธรดระดับเคอร์เนล• หรือ multiplex เธรดระดับผู้ใช้บนระดับ kernelหัวข้อ• Java Virtual Machine (JVM)หัวข้อ• Java มีเธรดระดับผู้ใช้•บน Unix รุ่นเก่า เพียงหนึ่ง "เธรดเคอร์เนล" ต่อกระบวนการ• Multiplex กระทู้จาวาทั้งหมดบนเธรดเคอร์เนลหนึ่งนี้•บน Windows NT, Unix ที่ทันสมัย•สามารถ multiplex หัวข้อ Java บนเธรดเคอร์เนลหลาย•สามารถกำหนดหัวข้อ Java เพิ่มเติมกว่ากระทู้เคอร์เนลใช้หัวข้อ•หัวข้อนำไปใช้มีปัญหา•อินเตอร์เฟซ•สลับบริบท• Preemptive เทียบกับที่ไม่ใช่ preemptive•ทำพวกเขาหมายถึงอะไร•การจัดกำหนดการ•ซิงโครไนซ์ (บรรยายถัดไป)•ความเธรดระดับผู้ใช้หัวข้อ•ระดับ kernel จะคล้ายกับกระบวนการเดิมจัดการและการใช้งานในระบบปฏิบัติการตัวอย่างหัวข้ออินเทอร์เฟซ• thread_create (procedure_t อาร์กิวเมนต์ของค่า)•สร้างหัวข้อใหม่ของตัวควบคุม•เริ่มดำเนิน procedure_t• thread_yield()•ด้วยความสมัครใจให้หน่วยประมวลผล• thread_exit()•สิ้นสุดการเธรดเรียก ยัง thread_destroy• thread_join(target_thread)•ระงับการดำเนินการเรียกด้ายจนถึง target_threadสิ้นสุดลงเธรดการจัดกำหนดการ•สำหรับเธรดระดับผู้ใช้: วางแผนเกิดขึ้นทั้งหมดในพื้นที่ผู้ใช้•กำหนดการหัวข้อกำหนดเวลาการทำงานของเธรด•ใช้คิวเพื่อติดตามกระทู้จะทำอะไร•เช่นเดียวกับระบบปฏิบัติการและกระบวนการ• แต่ก็จะดำเนินการในระดับผู้ใช้ในไลบรารี•รันคิว: เธรดกำลังเรียกใช้ (ปกติ)•พร้อมคิว: เธรดพร้อมที่จะรัน•มีคิวรอตัวอย่างหัวข้ออินเทอร์เฟซ• thread_create (procedure_t อาร์กิวเมนต์ของค่า)•สร้างหัวข้อใหม่ของตัวควบคุม•เริ่มดำเนิน procedure_t• thread_yield()•ด้วยความสมัครใจให้หน่วยประมวลผล• thread_exit()•สิ้นสุดการเธรดเรียก ยัง thread_destroy• thread_join(target_thread)•ระงับการดำเนินการเรียกด้ายจนถึง target_threadสิ้นสุดลงหัวข้อสลับบริบท•ขั้นตอนการสลับบริบทไม่มหัศจรรย์ทั้งหมด•บันทึกเนื้อหาของหัวข้อที่กำลังทำงานอยู่ (old_thread)•ผลักดันสถานะเครื่องทั้งหมดลงในกองซ้อนของ•คืนค่าเนื้อหาของหัวข้อถัดไป•ป๊อปสถานะเครื่องทั้งหมดจากกองซ้อนของเธรดถัดไป•หัวข้อถัดไปกลายเป็น เธรดปัจจุบัน•กลับไปเรียกเป็นหัวข้อใหม่•ทั้งหมดทำเช่นนี้ในภาษาแอสเซมบลี•ดู โค้ง/mips/mips/สลับ ใน OS161 (เธรดเคอร์เนลนำไปใช้) รอสักครู่หนึ่ง•ไม่ใช่ preemptive เธรดได้ให้ด้วยความสมัครใจซีพียู•เพียงสมัครใจเรียก thread_yield() หรือ thread_exit()ทำให้สวิตช์บริบท•ถ้าหนึ่งเธรดไม่ปล่อย CPU (ไม่เรียกthread_yield())•ที่เราต้องการจัดกำหนดการ preemptive เธรดระดับผู้ใช้การจัดกำหนดการ preemptive• Preemptive แผนทำสลับบริบทที่ทำการ•ต้องสามารถควบคุมประมวลผลแบบอะซิงโครนัส•วิธี•ใช้เวลาขัดจังหวะ•จับสัญญาณขัดจังหวะตัวจัดการกองกำลังเธรดปัจจุบัน "โทร"thread_yield•วิธีกระบวนการเทียบกับหัวข้อ•มัลติเธรดเป็นเพียงตัวเลือกสำหรับ "งานสหกรณ์"•ความน่าเชื่อถือและการใช้ร่วมกัน•กระบวนการ•แยกแรงแต่ประสิทธิภาพต่ำ•หัวข้อ•ประสิทธิภาพดีแต่ใช้มากเกินไป•ตัวอย่าง: เว็บเบราว์เซอร์•ซาฟารี: มัลติเธรด•หนึ่งเว็บเพจสามารถผิดพลาดทั้งซาฟารี•กูเกิลโครม: แต่ละแท็บมีกระบวนการของตนเอง สรุปหัวข้อ•ระบบปฏิบัติการเป็นโปรแกรมให้ใหญ่•ดำเนินการแต่ละกระบวนการเป็นเธรดภายใต้ระบบปฏิบัติการ•มัลติเธรดเป็นประโยชน์มากสำหรับการใช้งาน•มัลติเธรดประสิทธิภาพต้องนำอย่างรวดเร็วกระบวนการ•มีเฮฟวี่เวทมากเกินไป•แก้ปัญหาจะแยกหัวข้อจากกระบวนการ•ระดับ kernel กระทู้ดี โอเวอร์เฮดแต่ยังคงสำคัญเธรดระดับผู้ใช้•รวมดีกว่า แต่ไม่ดีกับระบบปฏิบัติการ•ในตอนนี้ วิธีทำเราได้หัวข้อของเราจะร่วมมือกับอย่างถูกต้องกันและกัน•ตรง...

ผลลัพธ์ (ไทย) 2:

กระบวนการ•จำได้ว่าเป็นกระบวนการที่มีหลายสิ่งหลายอย่างงาน•พื้นที่ที่อยู่(กำหนดรหัสทั้งหมดและหน้าข้อมูล) •ทรัพยากร OS (เช่นไฟล์ที่เปิด) และข้อมูลบัญชี•การดำเนินการของรัฐ(PC, SP, Regs ฯลฯ ) •การสร้าง กระบวนการใหม่เป็นค่าใช้จ่ายเพราะข้อมูลทั้งหมดโครงสร้างที่จะต้องได้รับการจัดสรรและเริ่มต้น• proc struct จำใน Solaris • ... ซึ่งไม่ได้รวมตารางหน้าอาจ TLB ล้าง ฯลฯ•การสื่อสารระหว่างกระบวนการเป็นค่าใช้จ่ายเพราะส่วนใหญ่การสื่อสารผ่านไประบบปฏิบัติการ•ค่าใช้จ่ายของสายระบบและข้อมูลการคัดลอกโปรแกรมขนาน•ในการรันโปรแกรมเหล่านี้เราต้อง•สร้างกระบวนการหลายอย่างที่ดำเนินการในแบบคู่ขนาน•สาเหตุแต่ละแมปไปยังพื้นที่ที่อยู่เดียวกันในการใช้ข้อมูลร่วมกัน•พวกเขาเป็นส่วนหนึ่งของการคำนวณเดียวกัน•มีระบบปฏิบัติการกำหนดเวลากระบวนการเหล่านี้ในแบบคู่ขนาน•สถานการณ์เช่นนี้จะไม่มีประสิทธิภาพมาก•พื้นที่: PCB ตารางหน้า ฯลฯ•เวลา: สร้างโครงสร้างข้อมูลส้อมและคัดลอกพื้นที่ addr ฯลฯ• Solutions: เป็นไปได้ที่จะมีประสิทธิภาพมากขึ้น แต่ สหกรณ์"กระบวนการ"? กระบวนการทบทวน•อะไรคือสิ่งที่คล้ายกันในการให้ความร่วมมือในกระบวนการเหล่านี้หรือไม่•พวกเขาร่วมกันทุกรหัสเดียวกันและข้อมูล(พื้นที่ที่อยู่) •พวกเขาร่วมกันทุกสิทธิประโยชน์เดียวกัน•พวกเขาทั้งหมดร่วมกันทรัพยากรเดียวกัน (แฟ้มซ็อกเก็ต ฯลฯ ) •อะไรไม่ได้ที่พวกเขาร่วมกัน? •แต่ละคนมีการดำเนินการของรัฐของตัวเอง: PC, SP และลงทะเบียน•ความคิดที่สำคัญ: ทำไมเราไม่แยกแนวคิดของกระบวนการจากรัฐการดำเนินการของตนหรือไม่•กระบวนการ: พื้นที่ที่อยู่สิทธิ์ ทรัพยากร ฯลฯ •การดำเนินการของรัฐ: PC, SP, ลงทะเบียนรัฐ• Exec เรียกว่าด้ายควบคุมหรือกระทู้กระทู้•โมเดิร์นระบบปฏิบัติการ(Mac, Windows, Unix ที่ทันสมัย) แยกแนวคิดของกระบวนการและหัวข้อ•ด้ายกำหนดลำดับกระแสการดำเนินการภายในกระบวนการ (PC, SP ทะเบียน) •ขั้นตอนการกำหนดพื้นที่ที่อยู่และกระบวนการทั่วไปแอตทริบิวต์ (ทุกอย่าง แต่หัวข้อของการดำเนินการ) •ด้ายถูกผูกไว้กับขั้นตอนเดียว•กระบวนการแต่สามารถมีหลายหัวข้อ•กระทู้กลายเป็นหน่วยของการตั้งเวลา•กระบวนการอยู่ในขณะนี้ภาชนะที่กระทู้ดำเนินการเปรียบเทียบ: •กระบวนการ: •เช่า 4 วิศวกรซอฟต์แวร์ในการทำงานกับ 4 โครงการ•กระทู้: •มีวิศวกรคนหนึ่งในการทำงานกับ 4 โครงการรูปแบบด้าย•ข้อมูลที่ใช้ร่วมกัน•โปรเซสเซอร์ข้อมูล: การปกครองที่, เวลา, ฯลฯ•หน่วยความจำ: ส่วนโต๊ะหน้าและสถิติ ฯลฯ• I / O และไฟล์: พอร์ตสื่อสารไดเรกทอรีและอธิบายไฟล์ ฯลฯ•รัฐภาคเอกชน•ลงทะเบียน•โปรแกรมเคาน์เตอร์•การดำเนินการสแต็ค•รัฐ( พร้อมทำงานและถูกปิดกั้น) •ทำไม? •แต่ละเธรดรันแยกกระทู้เคอร์เนลระดับ•เรามีการดำเนินการด้านการดำเนินการของกระบวนการและแยกมันออกไปในหัวข้อ•เพื่อให้เห็นพ้องด้วยราคาถูก•เช่นระบบปฏิบัติการตอนนี้จัดการกระทู้และกระบวนการ•การดำเนินงานทั้งหมดด้ายจะดำเนินการใน kernel •ตาราง OS ทุกหัวข้อในระบบ•หัวข้อOS ที่มีการจัดการที่เรียกว่าหัวข้อเคอร์เนลระดับหรือกระบวนการที่มีน้ำหนักเบา•หน้าต่าง: หัวข้อ• Solaris วิธีการที่มีน้ำหนักเบา (LWP) • POSIX กระทู้ ( pthreads): PTHREAD_SCOPE_SYSTEM เคอร์เนลระดับกระทู้ข้อ จำกัด •หัวข้อเคอร์เนลระดับให้พร้อมกันมากราคาถูกกว่ากระบวนการ•รัฐน้อยมากที่จะจัดสรรและเริ่มต้น•อย่างไรก็ตามสำหรับการเห็นพ้องละเอียดหัวข้อเคอร์เนลระดับยังคงทุกข์ทรมานจากค่าใช้จ่ายมากเกินไป•การดำเนินงานของกระทู้ยังคงต้องใช้สายระบบ•เป็นการดีที่ต้องการให้การดำเนินงานของด้ายที่จะเป็นเร็วที่สุดเท่าที่เรียกขั้นตอน•สำหรับการเห็นพ้องละเอียดดังกล่าวต้องแม้แต่"ถูกกว่า" หัวข้อระดับผู้ใช้กระทู้•เพื่อให้หัวข้อที่ถูกและเร็วพวกเขาจะต้องมีการดำเนินการที่ระดับผู้ใช้•หัวข้อเคอร์เนลระดับมีการจัดการโดยระบบปฏิบัติการ•หัวข้อระดับผู้ใช้มีการจัดการอย่างสิ้นเชิงโดยระบบเวลาทำงาน(ห้องสมุดระดับผู้ใช้) •หัวข้อระดับผู้ใช้ที่มีขนาดเล็กและรวดเร็ว•ด้ายเป็นตัวแทนเพียงโดยคอมพิวเตอร์ทะเบียนสแต็คและบล็อกควบคุมด้ายขนาดเล็ก (TCB) •การสร้างหัวข้อใหม่สลับไปมาระหว่างหัวข้อและตรงกันกระทู้จะทำผ่านการเรียกขั้นตอน•ไม่มีส่วนร่วมเคอร์เนลการดำเนินงานด้าย•ผู้ใช้ระดับ100x เร็วกว่าหัวข้อเคอร์เนล• pthreads: PTHREAD_SCOPE_PROCESS ระดับผู้ใช้ข้อ จำกัด กระทู้• แต่หัวข้อระดับผู้ใช้ไม่ได้เป็นโซลูชั่นที่สมบูรณ์แบบ•เช่นเดียวกับทุกสิ่งทุกอย่างที่พวกเขาจะถ่วงดุลอำนาจ•หัวข้อระดับผู้ใช้จะมองไม่เห็นระบบปฏิบัติการ•พวกเขาจะไม่บูรณาการได้ดีกับระบบปฏิบัติการ•เป็นผลให้ระบบปฏิบัติการสามารถทำให้การตัดสินใจที่ยากจน•ตั้งเวลากระบวนการที่มีหัวข้อไม่ได้ใช้งาน•การปิดกั้นกระบวนการที่มีด้ายเริ่มI / O แม้ว่ากระบวนการมีหัวข้ออื่นๆ ที่สามารถดำเนินการ•การแก้นี้ต้องใช้การสื่อสารระหว่างเคอร์เนลและด้ายระดับผู้ใช้ผู้จัดการKernel- กับหัวข้อที่ผู้ใช้ระดับ•หัวข้อเคอร์เนลระดับ•บูรณาการกับระบบปฏิบัติการ(การตั้งเวลาแจ้ง) •ช้าในการสร้าง, จัดการ, ประสาน•หัวข้อที่ผู้ใช้ระดับ•รวดเร็วในการสร้าง, จัดการ, ประสาน•บูรณาการไม่ได้อยู่กับระบบปฏิบัติการ(ไม่รู้ การจัดตารางเวลา) •การทำความเข้าใจความแตกต่างระหว่าง kernel- และหัวข้อระดับผู้ใช้เป็นสิ่งสำคัญ•สำหรับการเขียนโปรแกรม(ถูกต้องประสิทธิภาพ) •สำหรับการทดสอบการKernel- และผู้ใช้ระดับกระทู้•หรือใช้ทั้งสองหัวข้อkernel- และระดับผู้ใช้•สามารถเชื่อมโยงหัวข้อที่ใช้ในระดับเดียวกับด้ายเคอร์เนลระดับ•หรือหัวข้อหลายระดับผู้ใช้ที่ด้านบนของเมล็ดระดับหัวข้อ•โปรแกรมJava Virtual Machine (JVM) •หัวข้อ Java เป็นหัวข้อระดับผู้ใช้•บนระบบปฏิบัติการยูนิกซ์เก่าเพียงหนึ่ง"เคอร์เนล กระทู้ "ต่อกระบวนการ•มัลติเธรดJava ทั้งหมดในหัวข้อนี้เคอร์เนลหนึ่ง•ในWindows NT, Unix ทันสมัย•สามารถmultiplex หัวข้อ Java บนหัวข้อเคอร์เนลหลาย•สามารถมีหัวข้อJava มากกว่าหัวข้อเคอร์เนลการใช้ด้าย•การใช้กระทู้มีจำนวนของปัญหา• อินเตอร์เฟซ•สวิทช์บริบท• Preemptive เทียบกับที่ไม่ใช่มาตรการ•สิ่งใดที่พวกเขาหมายถึงอะไร•การจัดตารางเวลา•การประสาน(บรรยายถัดไป) •มุ่งเน้นหัวข้อระดับผู้ใช้•หัวข้อเคอร์เนลระดับที่มีความคล้ายคลึงกับกระบวนการเดิมการจัดการและการดำเนินงานในระบบปฏิบัติการกระทู้ตัวอย่างอินเตอร์เฟซ• thread_create (procedure_t, หาเรื่อง) •สร้างหัวข้อใหม่ในการควบคุม•เริ่มต้นการดำเนิน procedure_t • thread_yield () •สมัครใจให้ขึ้นโปรเซสเซอร์• thread_exit () •ยุติด้ายเรียก; ยัง thread_destroy • thread_join (target_thread) •ระงับการดำเนินการของการเรียกด้ายจนกว่า target_thread ยุติกระทู้ตั้งเวลา•สำหรับด้ายระดับผู้ใช้: การตั้งเวลาที่เกิดขึ้นทั้งหมดในผู้ใช้พื้นที่•กำหนดการด้ายกำหนดเมื่อด้ายทำงาน•จะใช้คิวที่จะติดตามสิ่งที่หัวข้อกำลังทำ•เช่นเดียวกับระบบปฏิบัติการและกระบวนการ• แต่จะดำเนินการในระดับผู้ใช้ในห้องสมุด•คิวเรียกใช้: กระทู้ทำงานอยู่ในปัจจุบัน (ปกติ) •คิวพร้อม: กระทู้พร้อมที่จะทำงาน•มีรอคิว? กระทู้ตัวอย่าง อินเตอร์เฟซ• thread_create (procedure_t, หาเรื่อง) •สร้างหัวข้อใหม่ในการค%