ความแตกต่างทางเทคนิคระหว่างกระบวนการและเธรดคืออะไร

ฉันรู้สึกว่าคำว่า 'กระบวนการ' ใช้มากเกินไป และยังมีเธรดฮาร์ดแวร์และซอฟต์แวร์อีกด้วย แล้วกระบวนการน้ำหนักเบาในภาษาอย่างErlangล่ะ? มีเหตุผลที่ชัดเจนในการใช้คำหนึ่งคำกับอีกคำหนึ่งหรือไม่?

ตอบ

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

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

Erlang ใช้คำว่า "กระบวนการ" เพราะไม่เปิดเผยโมเดลมัลติโปรแกรมหน่วยความจำที่ใช้ร่วมกัน การเรียกพวกเขาว่า "กระทู้" แสดงว่าพวกเขามีความทรงจำร่วมกัน

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

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


พบข้อมูลนี้ใน Microsoft Docs ที่นี่: เกี่ยวกับกระบวนการและเธรด

Microsoft Windows supports preemptive multitasking, which creates the effect of simultaneous execution of multiple threads from multiple processes. On a multiprocessor computer, the system can simultaneously execute as many threads as there are processors on the computer.

กระบวนการ:

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

เกลียว:

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

ฉันยืมข้อมูลข้างต้นจากเควสความรู้! บล็อก

ขั้นแรกให้ดูที่แง่มุมทางทฤษฎี คุณต้องเข้าใจว่ากระบวนการคืออะไรในแนวความคิดเพื่อทำความเข้าใจความแตกต่างระหว่างกระบวนการและเธรดและสิ่งที่แบ่งปันระหว่างกัน

เรามีส่วนต่อไปนี้ในหัวข้อ2.2.2 The Classical Thread ModelของModern Operating Systems 3eโดย Tanenbaum:

The process model is based on two independent concepts: resource grouping and execution. Sometimes it is use­ful to separate them; this is where threads come in....

เขาพูดต่อ:

One way of looking at a process is that it is a way to group related resources together. A process has an address space containing program text and data, as well as other resources. These resource may include open files, child processes, pending alarms, signal handlers, accounting information, and more. By putting them together in the form of a process, they can be managed more easily. The other concept a process has is a thread of execution, usually shortened to just thread. The thread has a program counter that keeps track of which instruc­tion to execute next. It has registers, which hold its current working variables. It has a stack, which contains the execution history, with one frame for each proce­dure called but not yet returned from. Although a thread must execute in some process, the thread and its process are different concepts and can be treated sepa­rately. Processes are used to group resources together; threads are the entities scheduled for execution on the CPU.

ด้านล่างเขามีตารางต่อไปนี้:

Per process items             | Per thread items
------------------------------|-----------------
Address space                 | Program counter
Global variables              | Registers
Open files                    | Stack
Child processes               | State
Pending alarms                |
Signals and signal handlers   |
Accounting information        |

มาจัดการกับปัญหาฮาร์ดแวร์มัลติเธรดกัน โดยทั่วไปแล้ว CPU จะสนับสนุนการประมวลผลเธรดเดียว รักษาสถานะของเธรดผ่านตัวนับโปรแกรมเดียว(PC) และชุดรีจิสเตอร์ แต่จะเกิดอะไรขึ้นเมื่อมีแคชพลาด? ใช้เวลานานในการดึงข้อมูลจากหน่วยความจำหลัก และในขณะที่เกิดเหตุการณ์นั้น CPU จะอยู่เฉยๆ ดังนั้นบางคนจึงมีความคิดที่จะมีสถานะเธรดสองชุด (PC + registers) เพื่อให้เธรดอื่น (อาจอยู่ในกระบวนการเดียวกัน อาจอยู่ในกระบวนการที่แตกต่างกัน) สามารถทำงานได้ในขณะที่เธรดอื่นกำลังรอหน่วยความจำหลัก มีหลายชื่อและการนำแนวคิดนี้ไปใช้ เช่นHyper-threadingและmultithreading พร้อมกัน (ย่อมาจาก SMT)

ทีนี้มาดูที่ด้านซอฟต์แวร์กัน โดยทั่วไปมีสามวิธีที่สามารถใช้เธรดในด้านซอฟต์แวร์ได้

  1. เธรดพื้นที่ผู้ใช้
  2. เธรดเคอร์เนล
  3. การรวมกันของทั้งสอง

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

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

อีกวิธีหนึ่งคือการรวมทั้งสองเข้าด้วยกัน โดยมีเคอร์เนลหลายเธรด แต่ละเธรดมีผู้ใช้หลายเธรด

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

เพื่ออธิบายเพิ่มเติมเกี่ยวกับการเขียนโปรแกรมพร้อมกัน

  1. กระบวนการมีสภาพแวดล้อมการดำเนินการในตัวเอง กระบวนการโดยทั่วไปมีชุดทรัพยากรรันไทม์พื้นฐานที่สมบูรณ์และเป็นส่วนตัว โดยเฉพาะอย่างยิ่ง แต่ละกระบวนการมีพื้นที่หน่วยความจำของตัวเอง

  2. มีเธรดอยู่ภายในกระบวนการ - ทุกกระบวนการมีอย่างน้อยหนึ่งรายการ เธรดแบ่งปันทรัพยากรของกระบวนการ รวมถึงหน่วยความจำและไฟล์ที่เปิดอยู่ สิ่งนี้ทำให้การสื่อสารมีประสิทธิภาพ แต่อาจมีปัญหา

ตัวอย่างการคำนึงถึงคนทั่วไป:

บนคอมพิวเตอร์ของคุณ เปิด Microsoft Word และเว็บเบราว์เซอร์ เราเรียกกระบวนการทั้งสองนี้ว่า

ใน Microsoft Word คุณพิมพ์บางอย่าง แล้วระบบจะบันทึกโดยอัตโนมัติ ตอนนี้ คุณสังเกตเห็นว่าการแก้ไขและการบันทึกเกิดขึ้นพร้อมกัน - แก้ไขในเธรดหนึ่งและบันทึกในเธรดอื่น

An application consists of one or more processes. A process, in the simplest terms, is an executing program. One or more threads run in the context of the process. A thread is the basic unit to which the operating system allocates processor time. A thread can execute any part of the process code, including parts currently being executed by another thread. A fiber is a unit of execution that must be manually scheduled by the application. Fibers run in the context of the threads that schedule them.

ขโมยมาจากที่นี่

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

กระบวนการ:

  1. กระบวนการเป็นกระบวนการที่มีน้ำหนักมาก
  2. กระบวนการเป็นโปรแกรมแยกต่างหากที่มีหน่วยความจำ ข้อมูล ทรัพยากร ฯลฯ แยกจากกัน
  3. กระบวนการถูกสร้างขึ้นโดยใช้วิธี fork()
  4. การสลับบริบทระหว่างกระบวนการใช้เวลานาน

ตัวอย่าง:
สมมติว่าเปิดเบราว์เซอร์ใดก็ได้ (mozilla, Chrome, IE) ณ จุดนี้กระบวนการใหม่จะเริ่มดำเนินการ

หัวข้อ:

  1. เธรดเป็นกระบวนการที่มีน้ำหนักเบา เธรดถูกรวมเข้าด้วยกันภายในกระบวนการ
  2. เธรดมีหน่วยความจำที่ใช้ร่วมกัน ข้อมูล ทรัพยากร ไฟล์ ฯลฯ
  3. เธรดถูกสร้างขึ้นโดยใช้เมธอด clone()
  4. การสลับบริบทระหว่างเธรดไม่ใช้เวลานานเท่ากระบวนการ

ตัวอย่างจริงสำหรับกระบวนการและเธรด สิ่งนี้จะทำให้คุณมีแนวคิดพื้นฐานเกี่ยวกับเธรดและกระบวนการ ใส่คำอธิบายภาพที่นี่

ฉันยืมข้อมูลข้างต้นจากคำตอบของ Scott Langham - ขอบคุณ

  • ทุกกระบวนการเป็นเธรด (เธรดหลัก)
  • แต่ทุกเธรดไม่ใช่กระบวนการ เป็นส่วนหนึ่ง (เอนทิตี) ของกระบวนการ

ทั้งเธรดและกระบวนการต่าง ๆ เป็นหน่วยอะตอมของการจัดสรรทรัพยากร OS (กล่าวคือ มีโมเดลการทำงานพร้อมกันที่อธิบายวิธีแบ่งเวลาของ CPU ระหว่างกัน และแบบจำลองของการเป็นเจ้าของทรัพยากร OS อื่นๆ) มีความแตกต่างใน:

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

Greg Hewgill ด้านบนนั้นถูกต้องเกี่ยวกับความหมายของ Erlang ของคำว่า "กระบวนการ" และนี่คือการพูดคุยกันว่าทำไม Erlang จึงสามารถทำกระบวนการแบบเบาได้

http://lkml.iu.edu/hypermail/linux/kernel/9608/0191.html

Linus Torvalds ([email protected])

Tue, 6 Aug 1996 12:47:31 +0300 (EET DST)

Messages sorted by: [ date ][ thread ][ subject ][ author ]

Next message: Bernd P. Ziller: "Re: Oops in get_hash_table"

Previous message: Linus Torvalds: "Re: I/O request ordering"

On Mon, 5 Aug 1996, Peter P. Eiserloh wrote:

We need to keep a clear the concept of threads. Too many people seem to confuse a thread with a process. The following discussion does not reflect the current state of linux, but rather is an attempt to stay at a high level discussion.

NO!

There is NO reason to think that "threads" and "processes" are separate entities. That's how it's traditionally done, but I personally think it's a major mistake to think that way. The only reason to think that way is historical baggage.

Both threads and processes are really just one thing: a "context of execution". Trying to artificially distinguish different cases is just self-limiting.

A "context of execution", hereby called COE, is just the conglomerate of all the state of that COE. That state includes things like CPU state (registers etc), MMU state (page mappings), permission state (uid, gid) and various "communication states" (open files, signal handlers etc). Traditionally, the difference between a "thread" and a "process" has been mainly that a threads has CPU state (+ possibly some other minimal state), while all the other context comes from the process. However, that's just one way of dividing up the total state of the COE, and there is nothing that says that it's the right way to do it. Limiting yourself to that kind of image is just plain stupid.

The way Linux thinks about this (and the way I want things to work) is that there is no such thing as a "process" or a "thread". There is only the totality of the COE (called "task" by Linux). Different COE's can share parts of their context with each other, and one subset of that sharing is the traditional "thread"/"process" setup, but that should really be seen as ONLY a subset (it's an important subset, but that importance comes not from design, but from standards: we obviusly want to run standards-conforming threads programs on top of Linux too).

In short: do NOT design around the thread/process way of thinking. The kernel should be designed around the COE way of thinking, and then the pthreads library can export the limited pthreads interface to users who want to use that way of looking at COE's.

Just as an example of what becomes possible when you think COE as opposed to thread/process:

  • You can do a external "cd" program, something that is traditionally impossible in UNIX and/or process/thread (silly example, but the idea is that you can have these kinds of "modules" that aren't limited to the traditional UNIX/threads setup). Do a:

clone(CLONE_VM|CLONE_FS);

child: execve("external-cd");

/* the "execve()" will disassociate the VM, so the only reason we used CLONE_VM was to make the act of cloning faster */

  • You can do "vfork()" naturally (it meeds minimal kernel support, but that support fits the CUA way of thinking perfectly):

clone(CLONE_VM);

child: continue to run, eventually execve()

mother: wait for execve

  • you can do external "IO deamons":

clone(CLONE_FILES);

child: open file descriptors etc

mother: use the fd's the child opened and vv.

All of the above work because you aren't tied to the thread/process way of thinking. Think of a web server for example, where the CGI scripts are done as "threads of execution". You can't do that with traditional threads, because traditional threads always have to share the whole address space, so you'd have to link in everything you ever wanted to do in the web server itself (a "thread" can't run another executable).

Thinking of this as a "context of execution" problem instead, your tasks can now chose to execute external programs (= separate the address space from the parent) etc if they want to, or they can for example share everything with the parent except for the file descriptors (so that the sub-"threads" can open lots of files without the parent needing to worry about them: they close automatically when the sub-"thread" exits, and it doesn't use up fd's in the parent).

Think of a threaded "inetd", for example. You want low overhead fork+exec, so with the Linux way you can instead of using a "fork()" you write a multi-threaded inetd where each thread is created with just CLONE_VM (share address space, but don't share file descriptors etc). Then the child can execve if it was a external service (rlogind, for example), or maybe it was one of the internal inetd services (echo, timeofday) in which case it just does it's thing and exits.

You can't do that with "thread"/"process".

Linus

พยายามตอบคำถามนี้เกี่ยวกับโลก Java

กระบวนการคือการดำเนินการของโปรแกรม แต่เธรดเป็นลำดับการดำเนินการเดียวภายในกระบวนการ กระบวนการสามารถมีหลายเธรด ด้ายบางครั้งเรียกว่ากระบวนการที่มีน้ำหนักเบา

ตัวอย่างเช่น:

ตัวอย่างที่ 1: JVM ทำงานในกระบวนการเดียวและเธรดใน JVM แบ่งฮีปที่เป็นของกระบวนการนั้น นั่นคือเหตุผลที่หลายเธรดอาจเข้าถึงวัตถุเดียวกันได้ เธรดแบ่งฮีปและมีพื้นที่สแต็กของตัวเอง นี่คือวิธีที่การเรียกใช้เมธอดของเธรดหนึ่งและตัวแปรในเครื่องนั้นทำให้เธรดปลอดภัยจากเธรดอื่น แต่ฮีปไม่ปลอดภัยสำหรับเธรด และต้องซิงโครไนซ์เพื่อความปลอดภัยของเธรด

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

สำหรับผู้ที่สะดวกกับการเรียนรู้ด้วยการแสดงภาพ นี่คือไดอะแกรมที่มีประโยชน์ซึ่งฉันสร้างขึ้นเพื่ออธิบายกระบวนการและเธรด
ฉันใช้ข้อมูลจาก MSDN - เกี่ยวกับกระบวนการและเธรด

กระบวนการและเธรด

กำลังพยายามตอบจาก OS View ของ Linux Kernel

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

task_struct

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

ภายในเคอร์เนล แต่ละเธรดมีเคอร์เนลสแต็กของตัวเองพร้อมกับtask_structโครงสร้างที่กำหนดเธรด ดังนั้นเคอร์เนลจึงดูเธรดของกระบวนการเดียวกันเป็นเอนทิตีที่แตกต่างกันและสามารถจัดกำหนดการได้เอง เธรดในกระบวนการเดียวกันใช้ id ทั่วไปที่เรียกว่าเป็น thread group id ( tgid) นอกจากนี้ยังมี id เฉพาะที่เรียกว่าเป็น id กระบวนการ ( pid)

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

กระบวนการ

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

เกลียว

เธรดเป็นหน่วยพื้นฐานของการใช้งาน CPU ประกอบด้วย ID เธรด ตัวนับโปรแกรม ชุดรีจิสเตอร์ และสแต็ก มันแชร์กับเธรดอื่นที่เป็นของกระบวนการเดียวกัน ส่วนรหัส ส่วนข้อมูล และทรัพยากรระบบปฏิบัติการอื่น ๆ เช่น ไฟล์ที่เปิดอยู่และสัญญาณ

-- นำมาจากระบบปฏิบัติการโดย Galvin

ความแตกต่างระหว่างเธรดและกระบวนการ?

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

ความแตกต่างอีกประการระหว่างเธรดและกระบวนการคือ เธรดภายในกระบวนการเดียวกันใช้พื้นที่ที่อยู่เดียวกัน ในขณะที่กระบวนการที่แตกต่างกันไม่ใช้ สิ่งนี้ทำให้เธรดสามารถอ่านและเขียนไปยังโครงสร้างข้อมูลและตัวแปรเดียวกัน และยังอำนวยความสะดวกในการสื่อสารระหว่างเธรด การสื่อสารระหว่างกระบวนการ - หรือที่เรียกว่า IPC หรือการสื่อสารระหว่างกระบวนการ - ค่อนข้างยากและใช้ทรัพยากรมาก

Here’s a summary of the differences between threads and processes:

  1. เธรดสร้างได้ง่ายกว่ากระบวนการ เนื่องจากไม่ต้องการพื้นที่ที่อยู่แยกต่างหาก

  2. มัลติเธรดต้องใช้การเขียนโปรแกรมอย่างระมัดระวัง เนื่องจากเธรดใช้โครงสร้างข้อมูลร่วมกัน ซึ่งควรแก้ไขทีละเธรดเท่านั้น ต่างจากเธรด กระบวนการต่างๆ ไม่ได้ใช้พื้นที่ที่อยู่เดียวกัน

  3. เธรดถือว่ามีน้ำหนักเบาเพราะใช้ทรัพยากรน้อยกว่ากระบวนการมาก

  4. กระบวนการเป็นอิสระจากกัน เธรด เนื่องจากเธรดที่ใช้พื้นที่ที่อยู่เดียวกันนั้นต้องพึ่งพาอาศัยกัน ดังนั้นจึงต้องระมัดระวังเพื่อไม่ให้เธรดที่ต่างกันมาเหยียบกัน
    นี่เป็นอีกวิธีหนึ่งในการระบุ #2 ด้านบน

  5. กระบวนการสามารถประกอบด้วยหลายเธรด

  1. เธรดทำงานในพื้นที่หน่วยความจำที่ใช้ร่วมกัน แต่กระบวนการทำงานในพื้นที่หน่วยความจำแยกต่างหาก
  2. เธรดเป็นกระบวนการที่มีน้ำหนักเบา แต่กระบวนการนั้นเป็นกระบวนการที่มีน้ำหนักมาก
  3. เธรดเป็นประเภทย่อยของกระบวนการ

จากมุมมองของผู้สัมภาษณ์ โดยพื้นฐานแล้ว มีเพียง 3 เรื่องหลักที่ฉันต้องการจะได้ยิน นอกจากสิ่งที่ชัดเจน เช่น กระบวนการสามารถมีหลายเธรดได้:

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

หากคุณต้องการมากกว่านี้ คำตอบของ Scott Langham ค่อนข้างครอบคลุมทุกอย่าง ทั้งหมดนี้มาจากมุมมองของระบบปฏิบัติการ ภาษาต่างๆ สามารถใช้แนวคิดที่แตกต่างกันได้ เช่น งาน เธรดแบบ light-wigh และอื่นๆ แต่เป็นวิธีการใช้เธรด (ของไฟเบอร์บน Windows) ไม่มีเธรดฮาร์ดแวร์และซอฟต์แวร์ มีฮาร์ดแวร์และซอฟต์แวร์ที่เป็นข้อยกเว้นและการขัดจังหวะหรือใช้โหมดเคอร์เนลหัวข้อ

ต่อไปนี้คือสิ่งที่ผมได้จากหนึ่งในบทความในโครงการรหัส ฉันเดาว่ามันอธิบายทุกอย่างที่จำเป็นอย่างชัดเจน

A thread is another mechanism for splitting the workload into separate execution streams. A thread is lighter weight than a process. This means, it offers less flexibility than a full blown process, but can be initiated faster because there is less for the Operating System to set up. When a program consists of two or more threads, all the threads share a single memory space. Processes are given separate address spaces. all the threads share a single heap. But each thread is given its own stack.

กระบวนการ:

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

เกลียว:

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

อ้างอิงhttps://practice.geeksforgeeks.org/problems/difference-between-process-and-thread

มาจากโลกที่ฝังตัว ฉันต้องการเพิ่มว่าแนวคิดของกระบวนการมีอยู่ในโปรเซสเซอร์ "ใหญ่" เท่านั้น ( ซีพียูเดสก์ท็อป, ARM Cortex A-9 ) ที่มี MMU (หน่วยจัดการหน่วยความจำ) และระบบปฏิบัติการที่รองรับการใช้ MMU ( เช่นลินุกซ์ ). ด้วยโปรเซสเซอร์และไมโครคอนโทรลเลอร์ขนาดเล็ก/เก่า และระบบปฏิบัติการ RTOS ขนาดเล็ก (ระบบปฏิบัติการแบบเรียลไทม์ ) เช่น freeRTOS จึงไม่รองรับ MMU ดังนั้นจึงไม่มีกระบวนการใดๆ มีแต่เธรดเท่านั้น

เธรดสามารถเข้าถึงหน่วยความจำของกันและกัน และกำหนดตารางเวลาโดย OS ในลักษณะอินเตอร์ลีฟ เพื่อให้ดูเหมือนว่าจะทำงานแบบขนาน

กระบวนการในมืออื่น ๆ ที่อาศัยอยู่ในกระบะทรายส่วนตัวของพวกเขาจากหน่วยความจำเสมือนที่ให้บริการและรักษาโดย MMU สิ่งนี้มีประโยชน์เพราะช่วยให้:

  1. ทำให้กระบวนการบั๊กกี้ไม่ล่มทั้งระบบ
  2. การรักษาความปลอดภัยด้วยการทำให้ข้อมูลกระบวนการอื่นๆ มองไม่เห็นและไม่สามารถเข้าถึงได้ งานจริงภายในกระบวนการได้รับการดูแลโดยเธรดตั้งแต่หนึ่งรายการขึ้นไป
  1. โดยทั่วไป เธรดเป็นส่วนหนึ่งของกระบวนการที่ไม่มีกระบวนการ เธรดไม่สามารถทำงานได้
  2. เธรดมีน้ำหนักเบาในขณะที่กระบวนการนั้นมีน้ำหนักมาก
  3. การสื่อสารระหว่างกระบวนการต้องใช้เวลาในขณะที่เธรดใช้เวลาน้อยลง
  4. เธรดสามารถใช้พื้นที่หน่วยความจำร่วมกันได้ในขณะที่กระบวนการทำงานแยกจากกัน

กระบวนการ : โปรแกรมที่กำลังดำเนินการเรียกว่ากระบวนการ

เธรด : เธรดเป็นฟังก์ชันที่ดำเนินการกับส่วนอื่น ๆ ของโปรแกรมตามแนวคิดของ "หนึ่งกับอย่างอื่น" ดังนั้นเธรดจึงเป็นส่วนหนึ่งของกระบวนการ..

ฉันได้อ่านคำตอบเกือบทั้งหมดแล้ว แต่ในฐานะที่เป็นนักศึกษาระดับปริญญาตรีที่กำลังเรียนหลักสูตร OS อยู่ในขณะนี้ ฉันไม่เข้าใจทั้งสองแนวคิดอย่างละเอียดถี่ถ้วน ฉันหมายถึงผู้ชายส่วนใหญ่อ่านจากหนังสือ OS บางเล่มถึงความแตกต่าง เช่น เธรดสามารถเข้าถึงตัวแปรส่วนกลางในหน่วยธุรกรรมได้ เนื่องจากพวกเขาใช้พื้นที่ที่อยู่ของกระบวนการ ถึงกระนั้น คำถามใหม่ก็เกิดขึ้นว่าทำไมจึงมีกระบวนการ เรารู้ว่าเธรดนั้นเป็นกระบวนการที่เบากว่าเมื่อเทียบกับกระบวนการ ได้อย่างรวดเร็ว Let 's ตัวอย่างต่อไปนี้โดยการใช้ภาพที่ตัดตอนมาจากหนึ่งในคำตอบก่อน ,

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

ใส่คำอธิบายภาพที่นี่

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

ระบบมัลติคอร์อาจใช้การประมวลผลหลายเธรด ดังนั้น Python ควรสนับสนุนมัลติเธรด แต่งูใหญ่ไม่ได้เป็นภาษาที่รวบรวมและแทนที่จะเป็นภาษาตีความ1ซึ่งหมายความว่าโปรแกรมจะต้องถูกตีความเพื่อที่จะทำงาน และล่ามจะไม่รู้จักโปรแกรมก่อนที่จะเริ่มดำเนินการ อย่างไรก็ตาม สิ่งที่รู้คือกฎของ Python และนำกฎเหล่านั้นไปใช้แบบไดนามิก การเพิ่มประสิทธิภาพใน Python จะต้องเป็นการเพิ่มประสิทธิภาพของตัวแปลเองเป็นหลัก ไม่ใช่โค้ดที่จะเรียกใช้ สิ่งนี้ตรงกันข้ามกับภาษาที่คอมไพล์เช่น C ++ และมีผลที่ตามมาสำหรับมัลติเธรดใน Python โดยเฉพาะ Python ใช้ Global Interpreter Lock เพื่อจัดการมัลติเธรด

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

ในสภาพแวดล้อมสมัยใหม่ ล่ามของ Python ต้องอนุญาตให้ใช้ multi-threading และสิ่งนี้จะต้องปลอดภัยและมีประสิทธิภาพ นี่คือจุดที่ความแตกต่างระหว่างการเป็นภาษาที่แปลแล้วกับภาษาที่คอมไพล์เข้ามา ล่ามต้องไม่รบกวนข้อมูลที่แชร์ภายในจากเธรดต่างๆ ในขณะเดียวกันก็ปรับการใช้โปรเซสเซอร์ให้เหมาะสมสำหรับการคำนวณ

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

ใน Python ข้อมูลได้รับการปกป้องจากการเข้าถึงพร้อมกันโดยเธรดต่างๆ โดย Global Interpreter Lock มันต้องการให้โปรแกรม Python สามารถรันเธรดเดียวเท่านั้นได้ตลอดเวลา ในทางกลับกัน เป็นไปได้ที่จะรันหลายโพรเซส เนื่องจากหน่วยความจำสำหรับแต่ละโพรเซสถูกแยกออกจากโพรเซสอื่น และโพรเซสสามารถรันบนหลายคอร์ได้


1 Donald Knuth มีคำอธิบายที่ดีเกี่ยวกับกิจวัตรการตีความใน The Art of Computer Programming: Fundamental Algorithms

คำตอบที่ดีที่สุดที่ฉันพบคือ'The Linux Programming Interface' ของ Michael Kerrisk :

In modern UNIX implementations, each process can have multiple threads of execution. One way of envisaging threads is as a set of processes that share the same virtual memory, as well as a range of other attributes. Each thread is executing the same program code and shares the same data area and heap. However, each thread has it own stack containing local variables and function call linkage information. [LPI 2.12]

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

เธรดภายในกระบวนการเดียวกันใช้หน่วยความจำร่วมกัน แต่แต่ละเธรดมีสแต็กและรีจิสเตอร์ของตัวเอง และเธรดจะเก็บข้อมูลเฉพาะของเธรดในฮีป เธรดไม่เคยทำงานอย่างอิสระ ดังนั้นการสื่อสารระหว่างเธรดจึงเร็วกว่ามากเมื่อเทียบกับการสื่อสารระหว่างกระบวนการ

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

ตัวอย่างที่ 1: JVM ทำงานในกระบวนการเดียวและเธรดใน JVM แบ่งฮีปที่เป็นของกระบวนการนั้น นั่นคือเหตุผลที่หลายเธรดอาจเข้าถึงวัตถุเดียวกันได้ เธรดแบ่งฮีปและมีพื้นที่สแต็กของตัวเอง นี่คือวิธีที่การเรียกใช้เมธอดของเธรดหนึ่งและตัวแปรในเครื่องนั้นทำให้เธรดปลอดภัยจากเธรดอื่น แต่ฮีปไม่ปลอดภัยสำหรับเธรด และต้องซิงโครไนซ์เพื่อความปลอดภัยของเธรด

เกือบจะเหมือนกัน... แต่ความแตกต่างที่สำคัญคือเธรดมีน้ำหนักเบาและกระบวนการมีน้ำหนักมากในแง่ของการสลับบริบท ภาระงาน และอื่นๆ