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

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

Linux ใช้รูปแบบเธรด 1-1 โดยที่ (ไปยังเคอร์เนล) ไม่มีความแตกต่างระหว่างกระบวนการและเธรด - ทุกอย่างเป็นงานที่รันได้ง่าย * * * *

บน Linux การเรียกระบบcloneโคลนงานโดยมีระดับการแชร์ที่กำหนดค่าได้ซึ่ง ได้แก่ :

• CLONE_FILES: แชร์ตารางตัวบอกรายละเอียดไฟล์เดียวกัน (แทนที่จะสร้างสำเนา)
• CLONE_PARENT: อย่าตั้งค่าความสัมพันธ์พาเรนต์ - ลูกระหว่างงานใหม่กับงานเก่า (ไม่เช่นนั้นgetppid()= child's parent getpid())
• CLONE_VM: แบ่งปันพื้นที่หน่วยความจำเดียวกัน (แทนที่จะสร้างสำเนาCOW )

fork()เรียกclone(ใช้งานร่วมกันอย่างน้อย)และpthread_create()เรียกใช้งานร่วมกันมากที่สุดclone( )**

forkไอเอ็นจีมีค่าใช้จ่ายมากกว่าpthread_createไอเอ็นจีเล็กน้อยเนื่องจากการคัดลอกตารางและสร้างการแมป COW สำหรับหน่วยความจำ แต่นักพัฒนาเคอร์เนลลินุกซ์ได้ลอง (และประสบความสำเร็จ) ในการลดต้นทุนเหล่านั้น

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

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

* ประยุกต์ CLONE_THREADทำให้การส่งสัญญาณถูกแบ่งใช้ (ซึ่งต้องการCLONE_SIGHANDซึ่งแบ่งใช้ตารางตัวจัดการสัญญาณ)

** แบบง่าย มีอยู่ทั้งในSYS_forkและSYS_clonesyscalls แต่ใน kernel ที่sys_forkและsys_cloneมีทั้งห่อบางมากรอบเดียวฟังก์ชั่นที่ตัวเองเป็นเสื้อคลุมรอบบางdo_fork copy_processใช่คำว่าprocess, threadและtaskมีการใช้ค่อนข้างสลับกันในลินุกซ์ ...

Linux (และ Unix) ให้ตัวเลือกที่สามแก่คุณ

ตัวเลือก 1 - กระบวนการ

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

ตัวเลือก 2 - หัวข้อ

สร้างไฟล์ปฏิบัติการแบบสแตนด์อโลนซึ่งเริ่มต้นด้วยเธรดเดี่ยวและสร้างเธรดเพิ่มเติมเพื่อทำงานบางอย่าง

ตัวเลือก 3 - ทางแยก

มีเฉพาะใน Linux / Unix เท่านั้นซึ่งแตกต่างกันเล็กน้อย กระบวนการแยกเป็นจริงเป็นกระบวนการของตัวเองด้วยพื้นที่ที่อยู่ของตัวเอง - ไม่มีอะไรที่เด็กสามารถทำได้ (ปกติ) เพื่อส่งผลกระทบต่อพื้นที่ที่อยู่ของผู้ปกครองหรือพี่น้อง

อย่างไรก็ตามหน้าหน่วยความจำจะไม่ถูกคัดลอก แต่เป็น copy-on-write ดังนั้นมักจะใช้หน่วยความจำน้อยกว่าที่คุณคิด

พิจารณาโปรแกรมเว็บเซิร์ฟเวอร์ซึ่งประกอบด้วยสองขั้นตอน:

1. อ่านการกำหนดค่าและข้อมูลรันไทม์
2. แสดงคำขอหน้าเว็บ

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

ดังนั้นจึงมีสามตัวเลือกจริงๆ

ขึ้นอยู่กับปัจจัยหลายอย่าง กระบวนการหนักกว่าเธรดมากขึ้นและมีต้นทุนเริ่มต้นและปิดที่สูงขึ้น การสื่อสารระหว่างกระบวนการ (IPC) ก็ยากและช้ากว่าการสื่อสารระหว่างกัน

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

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

คนอื่น ๆ ได้กล่าวถึงการพิจารณา

บางทีความแตกต่างที่สำคัญคือในกระบวนการ Windows นั้นหนักและแพงเมื่อเทียบกับเธรดและใน Linux ความแตกต่างก็มีขนาดเล็กกว่ามากดังนั้นสมการจึงดุลในจุดที่ต่างกัน

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

ใน Linux ร่วมสมัย (2.6.x) มีประสิทธิภาพไม่แตกต่างกันมากนักระหว่างการสลับบริบทของกระบวนการเปรียบเทียบกับเธรด (เฉพาะ MMU stuff เท่านั้นที่เพิ่มเติมสำหรับเธรด) มีปัญหาเกี่ยวกับพื้นที่ที่อยู่ที่ใช้ร่วมกันซึ่งหมายความว่าตัวชี้ความผิดพลาดในเธรดอาจทำให้หน่วยความจำของกระบวนการหลักหรือเธรดอื่นเสียหายภายในพื้นที่ที่อยู่เดียวกัน

กระบวนการได้รับการปกป้องโดย MMU ดังนั้นตัวชี้ความผิดพลาดจะทำให้เกิดสัญญาณ 11 และไม่มีความเสียหาย

โดยทั่วไปแล้วฉันจะใช้กระบวนการ (ไม่ค่อยมีบริบทสลับค่าใช้จ่ายใน Linux แต่การป้องกันหน่วยความจำเนื่องจาก MMU) แต่ pthreads ถ้าฉันจะต้องเรียนตารางเวลาแบบเรียลไทม์ซึ่งเป็นถ้วยชาที่แตกต่างกันทั้งหมดเข้าด้วยกัน

ทำไมคุณคิดว่าเธรดมีประสิทธิภาพที่เพิ่มขึ้นอย่างมากใน Linux คุณมีข้อมูลใด ๆ สำหรับสิ่งนี้หรือมันเป็นเพียงตำนานหรือไม่?

งานของคุณเป็นอย่างไร

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

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

หน่วยเก็บเธรดโลคัลอนุญาตให้แต่ละเธรดมีอินสแตนซ์แยกกันของวัตถุส่วนกลาง ครั้งเดียวที่ฉันใช้มันคือเมื่อสร้างสภาพแวดล้อมการจำลองบน linux / windows สำหรับรหัสแอปพลิเคชันที่ทำงานใน RTOS ใน RTOS แต่ละงานเป็นกระบวนการที่มีพื้นที่ที่อยู่ของตัวเองในสภาพแวดล้อมการจำลองแต่ละงานคือเธรด (ที่มีพื้นที่ที่อยู่ที่ใช้ร่วมกัน) ด้วยการใช้ TLS สำหรับสิ่งต่าง ๆ เช่นซิงเกิลตันเราสามารถแยกอินสแตนซ์สำหรับแต่ละเธรดได้เหมือนกับภายใต้สภาพแวดล้อม RTOS 'ของจริง'

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

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

ฉันต้องเห็นด้วยกับสิ่งที่คุณได้ยิน เมื่อเราเปรียบเทียบกลุ่มของเรา ( xhplและอื่น ๆ ) เราจะได้รับประสิทธิภาพที่ดีขึ้นอย่างมีนัยสำคัญกับกระบวนการผ่านเธรด</anecdote>

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

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

สำหรับกรณีส่วนใหญ่ฉันต้องการกระบวนการมากกว่าเธรด เธรดอาจมีประโยชน์เมื่อคุณมีงานที่ค่อนข้างเล็ก (เวลาที่ใช้ในกระบวนการ >> โดยแต่ละหน่วยงานที่แบ่งออก) และจำเป็นที่จะต้องมีการแชร์หน่วยความจำระหว่างกัน คิดว่าเป็นชุดใหญ่ นอกจากนี้ (offtopic) โปรดทราบว่าหากการใช้งาน CPU ของคุณเท่ากับ 100 เปอร์เซ็นต์หรือใกล้เคียงกับการใช้งานจริงคุณจะไม่ได้รับประโยชน์จากการใช้มัลติเธรดหรือการประมวลผล (ในความเป็นจริงมันจะแย่ลง)

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

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

"ไม่มีโครงสร้างภายในที่ใช้กระบวนการหรือเธรด แต่มีโครงสร้าง task_struct ที่อธิบายหน่วยการตั้งเวลานามธรรมที่เรียกว่างาน"

นอกจากนี้ตาม Linus Torvalds คุณไม่ควรคิดถึงกระบวนการกับเธรดเลยและเนื่องจากการ จำกัด เกินไปและความแตกต่างเพียงอย่างเดียวคือ COE หรือบริบทของการดำเนินการในแง่ของ "แยกพื้นที่ที่อยู่จากแม่" หรือพื้นที่ที่อยู่ที่ใช้ร่วมกัน ในความเป็นจริงเขาใช้เว็บเซิร์ฟเวอร์เป็นตัวอย่างในการทำให้จุดของเขาที่นี่ (ซึ่งขอแนะนำให้อ่าน)

เครดิตแบบเต็มไปยังเอกสาร kernel ลินุกซ์

หากคุณต้องการแบ่งปันทรัพยากรคุณควรใช้เธรด

พิจารณาข้อเท็จจริงที่ว่าการสลับบริบทระหว่างเธรดนั้นมีราคาถูกกว่าการสลับบริบทระหว่างกระบวนการมาก

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