งานและกระบวนการ

โปรแกรมใด ๆ ที่ทำงานบน Linux เรียกว่า กระบวนการ. Linux ในฐานะระบบมัลติทาสกิ้งนั้นโดดเด่นด้วยความจริงที่ว่ากระบวนการหลายอย่างที่เป็นของผู้ใช้ตั้งแต่หนึ่งคนขึ้นไปสามารถดำเนินการได้พร้อม ๆ กัน คุณสามารถแสดงรายการกระบวนการที่กำลังทำงานอยู่โดยใช้คำสั่ง ปลตัวอย่างเช่นดังต่อไปนี้:

/home/larry# ps PID TT STAT TIME COMMAND 24 3 S 0:03 (ทุบตี) 161 3 R 0:00 ps /home/larry#

โปรดทราบว่าตามค่าเริ่มต้นคำสั่ง ปลแสดงรายการเฉพาะกระบวนการที่เป็นของผู้ใช้ที่เปิดใช้งานเท่านั้น หากต้องการดูกระบวนการทั้งหมดที่ทำงานอยู่ในระบบ คุณจะต้องออกคำสั่ง ป.ล . หมายเลขกระบวนการ(รหัสกระบวนการหรือ PID) ที่แสดงอยู่ในคอลัมน์แรกเป็นหมายเลขเฉพาะที่ระบบกำหนดให้กับแต่ละกระบวนการที่ทำงานอยู่ คอลัมน์สุดท้าย ส่วนหัว COMMAND ระบุชื่อของคำสั่งที่กำลังรัน ในกรณีนี้ รายการประกอบด้วยกระบวนการที่ผู้ใช้ลาร์รีเป็นผู้ดำเนินการเอง มีกระบวนการอื่น ๆ อีกมากมายที่ทำงานอยู่ในระบบ รายการทั้งหมดสามารถดูได้ด้วยคำสั่ง PS-aux. อย่างไรก็ตาม ในบรรดาคำสั่งที่รันโดยผู้ใช้ larry มีเพียง bash (เชลล์คำสั่งสำหรับผู้ใช้ larry) และคำสั่งนั้นเอง ปล. สามารถมองเห็น bash shell ทำงานพร้อมกับคำสั่งได้ ปล. เมื่อผู้ใช้ป้อนคำสั่ง ปล bash shell ก็เริ่มดำเนินการ หลังจากที่ทีมงาน ปลทำงานเสร็จแล้ว (ตารางกระบวนการปรากฏขึ้น) การควบคุมจะกลับสู่กระบวนการทุบตี จากนั้น bash shell จะแสดงพรอมต์และรอคำสั่งใหม่

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

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

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

โหมดเบื้องหน้าและเบื้องหลัง

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

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

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

สองสัญญาณ - หมายเลข 9 ( ฆ่า) และ 19 ( หยุด) - ระบบจะประมวลผลเสมอ จำเป็นต้องมีสิ่งแรกเพื่อฆ่ากระบวนการอย่างแน่นอน (จึงเป็นชื่อ) สัญญาณ หยุด ระงับ กระบวนการ: ในสถานะนี้ กระบวนการจะไม่ถูกลบออกจากตารางกระบวนการ แต่จะไม่ถูกดำเนินการจนกว่าจะได้รับสัญญาณ 18 ( ต่อ) - หลังจากนั้นจะทำงานต่อไป ในเชลล์คำสั่ง Linux สัญญาณ หยุดสามารถส่งผ่านไปยังกระบวนการที่ใช้งานอยู่ได้โดยใช้ลำดับการหลีกเลี่ยง Ctrl -ซี .

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

ถ่ายโอนไปยังพื้นหลังและทำลายงาน

เริ่มต้นด้วย ตัวอย่างง่ายๆ. มาดูคำสั่ง yes ซึ่งเมื่อมองแวบแรกอาจดูไร้ประโยชน์ คำสั่งนี้ส่งสตรีมสตริงที่ไม่มีที่สิ้นสุดซึ่งประกอบด้วยอักขระ y ไปยังเอาต์พุตมาตรฐาน มาดูกันว่าคำสั่งนี้ทำงานอย่างไร:

/home/larry# ใช่ ใช่ ใช่

ลำดับของบรรทัดดังกล่าวจะดำเนินต่อไปอย่างไม่มีกำหนด คุณสามารถทำลายกระบวนการนี้ได้โดยส่งสัญญาณขัดจังหวะไปเช่น โดยการกด Ctrl -ค. มาทำสิ่งที่แตกต่างกันตอนนี้ เพื่อป้องกันไม่ให้ลำดับที่ไม่มีที่สิ้นสุดนี้แสดงบนหน้าจอ เราจะเปลี่ยนเส้นทางเอาต์พุตมาตรฐานของคำสั่ง yes ไปที่ /dev/null ดังที่คุณอาจทราบแล้วว่าอุปกรณ์ /dev/null ทำหน้าที่เป็น "หลุมดำ": ข้อมูลทั้งหมดที่ส่งไปยังอุปกรณ์นี้จะสูญหาย การใช้อุปกรณ์นี้จะสะดวกมากในการกำจัดเอาต์พุตที่มากเกินไปจากบางโปรแกรม

/home/larry# ใช่ > /dev/null

ตอนนี้ไม่มีอะไรปรากฏบนหน้าจอ อย่างไรก็ตาม พรอมต์เชลล์จะไม่ถูกส่งกลับเช่นกัน เนื่องจากคำสั่ง yes ยังคงทำงานอยู่และส่งข้อความซึ่งประกอบด้วยตัวอักษร y ถึง /dev/null คุณยังสามารถทำลายงานนี้ได้ด้วยการส่งสัญญาณขัดจังหวะ

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

วิธีหนึ่งในการทำให้กระบวนการอยู่เบื้องหลังคือการผนวก & ต่อท้ายคำสั่ง ตัวอย่าง:

/home/larry# ใช่ > /dev/null & + 164 /home/larry#

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

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

/home/larry# งาน + ทำงานใช่ >/dev/null & /home/larry#

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

เพื่อส่งสัญญาณเข้าสู่กระบวนการ (ส่วนใหญ่มักมีความจำเป็น ขัดจังหวะ job job) มีการใช้ยูทิลิตี้ ฆ่า. คำสั่งนี้กำหนดหมายเลขงานหรือ PID เป็นอาร์กิวเมนต์ พารามิเตอร์ทางเลือกคือจำนวนสัญญาณที่ต้องส่งไปยังกระบวนการ โดยค่าเริ่มต้นสัญญาณจะถูกส่ง ภาคเรียน. ในกรณีข้างต้นหมายเลขงานคือ 1 ดังนั้นคำสั่ง ฆ่า %1จะขัดจังหวะการทำงาน เมื่อเข้าถึงงานด้วยหมายเลข (แทนที่จะเป็น PID) ตัวเลขนั้นจะต้องนำหน้าด้วยสัญลักษณ์เปอร์เซ็นต์ (“%”) บนบรรทัดคำสั่ง

ทีนี้มาป้อนคำสั่งกัน งานอีกครั้งเพื่อตรวจสอบผลลัพธ์ของการกระทำก่อนหน้า:

/home/larry# งานสิ้นสุดแล้ว ใช่ >/dev/null

ที่จริงแล้วงานถูกทำลาย และครั้งต่อไปที่คุณป้อนคำสั่ง jobs จะไม่มีข้อมูลเกี่ยวกับงานนั้นบนหน้าจอ

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

การหยุดชั่วคราวและดำเนินการต่องาน

ขั้นแรกเรามาเริ่มกระบวนการด้วยคำสั่ง yes ที่อยู่เบื้องหน้าเหมือนที่เคยทำมาก่อน:

/home/larry# ใช่ > /dev/null

เช่นเคย เนื่องจากกระบวนการกำลังทำงานอยู่เบื้องหน้า ดังนั้นเชลล์พรอมต์จึงไม่กลับไปที่หน้าจอ

ตอนนี้แทนที่จะขัดจังหวะงานด้วยคีย์ผสม Ctrl -ค, งานก็เป็นไปได้ ระงับ(ระงับตามตัวอักษร - เพื่อระงับ) ส่งสัญญาณให้เขา หยุด. หากต้องการหยุดงานชั่วคราว คุณต้องกดคีย์ผสมที่เหมาะสม ซึ่งโดยปกติจะเป็นเช่นนี้ Ctrl -ซี .

/home/larry# ใช่ > /dev/null Ctrl -ซี+ หยุดแล้ว ใช่ >/dev/null /home/larry#

กระบวนการที่ถูกระงับก็ไม่ได้ดำเนินการ ไม่ใช้ทรัพยากรของโปรเซสเซอร์ งานที่ระงับสามารถเริ่มรันจากจุดเดียวกับที่ไม่ถูกระงับได้

หากต้องการให้งานทำงานต่อในเบื้องหน้า คุณสามารถใช้คำสั่งได้ ฉ(จากคำว่าเบื้องหน้า - เบื้องหน้า)

/home/larry# fg ใช่ >/dev/null

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

/home/larry# bg + ใช่ $>$/dev/null & /home/larry#

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

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

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

งานที่ทำงานอยู่เบื้องหลังอาจพยายามแสดงข้อความบนหน้าจอ นี้จะรบกวนการทำงานอื่น ๆ

/home/larry# ใช่ &

ที่นี่เอาต์พุตมาตรฐานไม่ได้ถูกเปลี่ยนเส้นทางไปยังอุปกรณ์ /dev/null ดังนั้นกระแสอักขระ y ที่ไม่มีที่สิ้นสุดจะถูกพิมพ์ลงบนหน้าจอ ไม่สามารถหยุดเธรดนี้เนื่องจากคีย์ผสม Ctrl -คไม่ส่งผลกระทบต่องานในเบื้องหลัง หากต้องการหยุดเอาต์พุตนี้ คุณต้องใช้คำสั่ง ฉซึ่งจะนำงานมาไว้เบื้องหน้าแล้วทำลายงานด้วยคีย์ผสม Ctrl -ค .

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

นอกจากนี้ หากต้องการนำงานมาสู่เบื้องหน้า คุณสามารถระบุหมายเลขของงานได้อย่างง่ายดาย ใช่ครับ ทีม %2 จะเท่ากับคำสั่ง ฉ %2 .

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

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

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

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

หลังจากป้อนคำสั่งนี้ กระบวนการจะดำเนินต่อไปแต่จะอยู่เบื้องหลัง หากต้องการดูกระบวนการทั้งหมดที่ทำงานอยู่เบื้องหลัง คุณสามารถป้อนคำสั่งได้

ลองดูตัวอย่างง่ายๆ ของวิธีการนำไปใช้ สมมติว่าเรามีไฟล์ ซึ่งเราต้องแกะออก แต่เราไม่มีเวลารอ และเราต้องการทำงานแบบขนาน

กำลังคลายไฟล์เก็บถาวรในเบื้องหลัง

$ tar -czf home.tar.gz .

คลิก ศูนย์+Zจากนั้นป้อนคำสั่ง

$bg$งาน

วิธีที่สองคือการเพิ่ม & ที่ส่วนท้ายของคำสั่ง ซึ่งจะเป็นการบอกให้ระบบรันคำสั่งในเบื้องหลัง

$ tar -czf home.tar.gz . &$งาน

วิธีการนี้อนุญาตให้กระบวนการทำงานในเบื้องหลัง อย่างไรก็ตาม STDIN, STDOUT, เอสทีเดอร์ยังคงเชื่อมต่อกับเทอร์มินัล ตอนนี้เรามาดูกันว่ากระบวนการทำงานแม้ในขณะที่เทอร์มินัลปิดอยู่

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

$ sudo rsync Templates/* /var/www/html/ & $ งาน $ disown -h %1 $ งาน

คุณยังสามารถใช้คำสั่ง ไม่นะซึ่งจะทำให้กระบวนการทำงานต่อไปแม้ว่าผู้ใช้จะออกจากเชลล์ระบบก็ตาม

$ nohup tar -czf iso.tar.gz เทมเพลต/* & $ งาน

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

$firefox/dev/null &

ใน ระบบลินุกซ์(และบนระบบ Unix เกือบทั้งหมด) /dev/null เป็นไฟล์อุปกรณ์พิเศษ ซึ่งเรียกอีกอย่างว่า “อุปกรณ์ null” การเขียนทำได้สำเร็จโดยไม่คำนึงถึงปริมาณข้อมูลที่บันทึกไว้ การอ่านจากนั้นเทียบเท่ากับการอ่านจุดสิ้นสุดของไฟล์ (EOF)

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

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

สัญญาณลินุกซ์

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

รหัสสัญญาณ	ชื่อ	คำอธิบาย
1	ซิกอัพ	กำลังปิดเทอร์มินัล
2	ลงนาม	สัญญาณให้หยุดกระบวนการโดยผู้ใช้จากเทอร์มินัล (CTRL + C)
3	ซิคควิท	ส่งสัญญาณให้หยุดกระบวนการโดยผู้ใช้จากเทอร์มินัล (CTRL + \) ด้วยดัมพ์หน่วยความจำ
9	ซิกคิล	การยุติกระบวนการอย่างไม่มีเงื่อนไข
15	เครื่องหมาย	สัญญาณคำขอยุติกระบวนการ
17	ซิกสต็อป	บังคับให้กระบวนการถูกระงับแต่ไม่ยุติ
18	ซิกทีเอสพี	การหยุดกระบวนการชั่วคราวจากเทอร์มินัล (CTRL+Z) แต่ไม่ได้ปิดระบบ
19	ซิกคอนต์	ดำเนินการตามกระบวนการที่หยุดไว้ก่อนหน้านี้ต่อไป

หาก bash เชลล์ได้รับสัญญาณ SIGHUP เมื่อคุณปิดเทอร์มินัล มันจะออก ก่อนที่จะออก มันจะส่งสัญญาณ SIGHUP ไปยังกระบวนการทั้งหมดที่รันอยู่ในนั้น รวมถึงการรันสคริปต์ด้วย

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

สคริปต์ทุบตีไม่ได้ควบคุมสัญญาณเหล่านี้ แต่สามารถจดจำสัญญาณเหล่านั้นและดำเนินการคำสั่งบางอย่างเพื่อเตรียมสคริปต์สำหรับผลที่ตามมาที่เกิดจากสัญญาณ

การส่งสัญญาณไปยังสคริปต์

bash shell ช่วยให้คุณสามารถส่งสัญญาณไปยังสคริปต์โดยใช้แป้นพิมพ์ลัด สิ่งนี้มีประโยชน์มากหากคุณต้องการหยุดสคริปต์ที่ทำงานอยู่ชั่วคราวหรือยุติการทำงานของสคริปต์

การสิ้นสุดกระบวนการ

การผสมผสาน ปุ่ม CTRL+C สร้างสัญญาณ SIGINT และส่งไปยังกระบวนการทั้งหมดที่ทำงานในเชลล์ ส่งผลให้สัญญาณยุติลง

มารันคำสั่งต่อไปนี้ในเชลล์:

$นอน 100
หลังจากนั้นเราจะทำงานให้เสร็จโดยใช้คีย์ผสม CTRL + C

ยุติกระบวนการจากแป้นพิมพ์

หยุดกระบวนการชั่วคราว

คีย์ผสม CTRL + Z จะสร้างสัญญาณ SIGTSTP ซึ่งจะระงับกระบวนการแต่ไม่ได้ยุติกระบวนการ กระบวนการดังกล่าวยังคงอยู่ในหน่วยความจำและสามารถกลับมาทำงานต่อได้ มารันคำสั่งในเชลล์:

$นอน 100
และหยุดชั่วคราวด้วยคีย์ผสม CTRL + Z

หยุดกระบวนการชั่วคราว

หมายเลขในวงเล็บเหลี่ยมคือหมายเลขงานที่เชลล์กำหนดให้กับกระบวนการ เชลล์ถือว่ากระบวนการที่ทำงานอยู่ภายในเป็นงานที่มีตัวเลขเฉพาะ กระบวนการแรกถูกกำหนดหมายเลข 1 ที่สอง - 2 และอื่น ๆ

หากคุณหยุดงานที่เชื่อมโยงกับเชลล์ชั่วคราวและพยายามออกจากงานนั้น bash จะส่งคำเตือน

คุณสามารถดูงานที่ระงับได้โดยใช้คำสั่งต่อไปนี้:

ป.ล

รายการงาน

ในคอลัมน์ S ซึ่งแสดงสถานะของกระบวนการ T จะแสดงสำหรับกระบวนการที่ถูกระงับ สิ่งนี้บ่งชี้ว่าคำสั่งถูกระงับหรืออยู่ในสถานะการติดตาม

หากคุณต้องการยุติกระบวนการที่ถูกระงับ คุณสามารถใช้คำสั่ง kill คุณสามารถอ่านรายละเอียดเกี่ยวกับเรื่องนี้ได้

การโทรของเธอมีลักษณะดังนี้:

ฆ่า processID

การสกัดกั้นสัญญาณ

หากต้องการเปิดใช้งานการติดตามสัญญาณ Linux ในสคริปต์ ให้ใช้คำสั่ง trap หากสคริปต์ได้รับสัญญาณที่ระบุเมื่อเรียกใช้คำสั่งนี้ สคริปต์จะประมวลผลโดยแยกจากกัน ในขณะที่เชลล์จะไม่ประมวลผลสัญญาณดังกล่าว

คำสั่ง trap อนุญาตให้สคริปต์ตอบสนองต่อสัญญาณที่เชลล์จะถูกประมวลผลโดยปราศจากการแทรกแซง

ลองดูตัวอย่างที่แสดงให้เห็นว่าคำสั่ง trap ระบุโค้ดที่จะดำเนินการและรายการสัญญาณที่เราต้องการสกัดกั้นโดยคั่นด้วยช่องว่าง ในกรณีนี้เป็นเพียงสัญญาณเดียว:

#!/bin/bash trap "echo " Trapped Ctrl-C"" SIGINT echo นี่คือสคริปต์ทดสอบ count=1 ในขณะที่ [ $count -le 10 ] ทำ echo "Loop #$count" sleep 1 count=$(($ นับ + 1)) เสร็จแล้ว
คำสั่ง trap ที่ใช้ในตัวอย่างนี้จะส่งออก ข้อความเมื่อใดก็ตามที่ตรวจพบสัญญาณ SIGINT ซึ่งสามารถสร้างได้โดยการกด Ctrl + C บนแป้นพิมพ์

การสกัดกั้นสัญญาณ

ทุกครั้งที่คุณกด CTRL + C สคริปต์จะรันคำสั่ง echo ที่ระบุเมื่อเรียกการติดตาม แทนที่จะปล่อยให้เชลล์ยุติการทำงาน

คุณสามารถสกัดกั้นสัญญาณทางออกของสคริปต์ได้โดยใช้ชื่อของสัญญาณ EXIT เมื่อเรียกใช้คำสั่ง trap:

#!/bin/bash trap "echo Goodbye..." EXIT count=1 ในขณะที่ [ $count -le 5 ] ทำ echo "Loop #$count" sleep 1 count=$(($count + 1)) เสร็จแล้ว

การสกัดกั้นสัญญาณทางออกของสคริปต์

เมื่อสคริปต์ออก ทั้งตามปกติหรือเนื่องจากสัญญาณ SIGINT เชลล์จะสกัดกั้นและดำเนินการคำสั่ง echo

การปรับเปลี่ยนสัญญาณสกัดกั้นและยกเลิกการสกัดกั้น

หากต้องการแก้ไขสัญญาณที่สคริปต์ดักจับ คุณสามารถรันคำสั่ง trap ด้วยพารามิเตอร์ใหม่ได้:

#!/bin/bash trap "echo "Ctrl-C is trapped."" SIGINT count=1 ในขณะที่ [ $count -le 5 ] ทำ echo "Loop #$count" sleep 1 count=$(($count + 1) ) เสร็จสิ้นกับดัก "echo "ฉันแก้ไขกับดัก!" SIGINT count=1 ในขณะที่ [ $count -le 5 ] ทำ echo "Second Loop #$count" sleep 1 count=$(($count + 1)) เสร็จแล้ว

การปรับเปลี่ยนการสกัดกั้นสัญญาณ

หลังจากแก้ไขแล้ว สัญญาณจะถูกประมวลผลในรูปแบบใหม่

การสกัดกั้นสัญญาณสามารถยกเลิกได้เพียงดำเนินการคำสั่ง trap โดยส่งผ่านเครื่องหมายขีดคู่และชื่อสัญญาณ:

#!/bin/bash trap "echo "Ctrl-C is trapped."" SIGINT count=1 ในขณะที่ [ $count -le 5 ] ทำ echo "Loop #$count" sleep 1 count=$(($count + 1) ) เสร็จสิ้นกับดัก -- SIGINT echo "ฉันเพิ่งลบกับดัก" count=1 ในขณะที่ [ $count -le 5 ] ทำ echo "Second Loop #$count" sleep 1 count=$(($count + 1)) เสร็จแล้ว
หากสคริปต์ได้รับสัญญาณก่อนที่จะยกเลิกการสกัดกั้น สคริปต์จะประมวลผลตามที่ระบุไว้ใน ทีมปัจจุบันกับดัก. มารันสคริปต์กันเถอะ:

$ ./myscript
และกด CTRL + C บนแป้นพิมพ์

สัญญาณถูกสกัดกั้นก่อนที่จะยกเลิกการสกัดกั้น

การกด CTRL + C ครั้งแรกเกิดขึ้นในขณะที่เรียกใช้สคริปต์ เมื่อการสกัดกั้นสัญญาณมีผล ดังนั้นสคริปต์จึงดำเนินการคำสั่ง echo ที่กำหนดให้กับสัญญาณ หลังจากดำเนินการถึงคำสั่ง unhook คำสั่ง CTRL + C จะทำงานตามปกติโดยยุติสคริปต์

การรันสคริปต์บรรทัดคำสั่งในเบื้องหลัง

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

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

#!/bin/bash count=1 ในขณะที่ [ $count -le 10 ] do sleep 1 count=$(($count + 1)) เสร็จแล้ว
เรียกใช้งานโดยระบุอักขระเครื่องหมายและ (&) หลังชื่อ:

$ ./myscipt &
สิ่งนี้จะทำให้มันทำงานเป็นกระบวนการเบื้องหลัง

การรันสคริปต์ในเบื้องหลัง

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

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

รายการกระบวนการ

ด้วยวิธีนี้ หากคุณออกจากเทอร์มินัล สคริปต์ที่ทำงานอยู่เบื้องหลังก็จะออกเช่นกัน

จะทำอย่างไรถ้าคุณต้องการให้สคริปต์ทำงานต่อไปหลังจากปิดเทอร์มินัล?

การดำเนินการสคริปต์ที่ไม่ออกเมื่อปิดเทอร์มินัล

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

ลองใช้เทคนิคนี้เมื่อรันสคริปต์ของเรา:

ไม่นะ ./myscript &
นี่คือสิ่งที่จะส่งออกไปยังเทอร์มินัล

ทีมไม่เป็นไร

คำสั่ง nohup จะยกเลิกกระบวนการจากเทอร์มินัล ซึ่งหมายความว่ากระบวนการจะสูญเสียการอ้างอิงถึง STDOUT และ STDERR เพื่อไม่ให้ข้อมูลที่ส่งออกโดยสคริปต์สูญหาย nohup จะเปลี่ยนเส้นทางข้อความที่มาถึงใน STDOUT และ STDERR ไปยังไฟล์ nohup.out โดยอัตโนมัติ

โปรดทราบว่าหากคุณเรียกใช้สคริปต์หลายตัวจากไดเร็กทอรีเดียวกัน เอาต์พุตของสคริปต์เหล่านั้นจะจบลงที่ไฟล์ nohup.out ไฟล์เดียว

ดูงานที่มอบหมาย

คำสั่ง jobs อนุญาตให้คุณดูงานปัจจุบันที่กำลังรันอยู่ในเชลล์ มาเขียนสคริปต์ต่อไปนี้:

#!/bin/bash count=1 ในขณะที่ [ $count -le 10 ] ทำ echo "Loop #$count" sleep 10 count=$(($count + 1)) เสร็จแล้ว
มาเริ่มกันเลย:

$ ./myscript
และหยุดชั่วคราวด้วยคีย์ผสม CTRL + Z

การเรียกใช้และหยุดสคริปต์ชั่วคราว

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

$ ./myscript > ไฟล์ &
เมื่อดำเนินการคำสั่ง jobs เราจะเห็นข้อมูลเกี่ยวกับทั้งสคริปต์ที่ถูกระงับและสคริปต์ที่ทำงานอยู่เบื้องหลัง

รับข้อมูลเกี่ยวกับสคริปต์

สวิตช์ -l เมื่อเรียกใช้คำสั่ง jobs ระบุว่าเราต้องการข้อมูลเกี่ยวกับ ID กระบวนการ

เริ่มงานที่ถูกระงับอีกครั้ง

หากต้องการรีสตาร์ทสคริปต์ในเบื้องหลัง คุณสามารถใช้คำสั่ง bg

มารันสคริปต์กันเถอะ:

$ ./myscript
กด CTRL + Z ซึ่งจะหยุดการทำงานชั่วคราว มารันคำสั่งต่อไปนี้:

$บีจี

คำสั่งบีจี

ขณะนี้สคริปต์กำลังทำงานในเบื้องหลัง

หากคุณมีงานที่ถูกระงับหลายงาน คุณสามารถส่งหมายเลขงานไปยังคำสั่ง bg เพื่อรีสตาร์ทงานเฉพาะได้

เพื่อเริ่มงานใหม่อีกครั้ง โหมดปกติใช้คำสั่ง fg:

การวางแผนการรันสคริปต์

Linux มีสองวิธีในการรันสคริปต์ทุบตีในเวลาที่กำหนด นี่คือคำสั่ง at และตัวกำหนดเวลางาน cron

คำสั่ง at มีลักษณะดังนี้:

ที่เวลา [-f ชื่อไฟล์]
คำสั่งนี้รับรู้รูปแบบเวลาได้หลายรูปแบบ

• มาตรฐาน ระบุชั่วโมงและนาที เช่น 10:15 น.
• การใช้ตัวบ่งชี้ AM/PM ก่อนหรือหลังเที่ยง เช่น - 22:15 น.
• ใช้ชื่อพิเศษ เช่น ตอนนี้ เที่ยง เที่ยงคืน

นอกจากความสามารถในการระบุเวลาที่งานควรจะรันแล้ว คำสั่ง at ยังสามารถส่งผ่านวันที่โดยใช้รูปแบบใดรูปแบบหนึ่งที่รองรับได้อีกด้วย

• รูปแบบวันที่มาตรฐานซึ่งเขียนวันที่โดยใช้รูปแบบ MMDDYY, MM/DD/YY หรือ DD.MM.YY
• ข้อความที่แสดงวันที่ เช่น 4 กรกฎาคม หรือ 25 ธันวาคม โดยสามารถระบุปีได้ หรือคุณสามารถระบุได้โดยไม่ต้องระบุก็ได้
• อัดแบบตอนนี้ +25 นาที .
• บันทึกการเข้าดู 22:15 น. พรุ่งนี้ .
• ประเภทการบันทึก 10:15 + 7 วัน

อย่าไปเจาะลึกในหัวข้อนี้ ลองดูกรณีการใช้งานง่ายๆ สำหรับคำสั่ง:

$ ที่ -f ./myscript ทันที

การกำหนดเวลางานโดยใช้คำสั่ง at

สวิตช์ -M เมื่อโทรไปที่ใช้เพื่อส่งสิ่งที่สคริปต์ส่งออกไป อีเมลหากระบบได้รับการกำหนดค่าตามนั้น ถ้าส่ง อีเมลเป็นไปไม่ได้ สวิตช์นี้จะระงับเอาต์พุต

หากต้องการดูรายการงานที่รอดำเนินการ คุณสามารถใช้คำสั่ง atq:

รายการงานที่ค้างอยู่

กำลังลบงานที่ค้างอยู่

คำสั่ง atrm ช่วยให้คุณสามารถลบงานที่ค้างอยู่ได้ เมื่อเรียกให้ระบุหมายเลขงาน:

$เอทีเอ็ม 18

กำลังลบงาน

รันสคริปต์ตามกำหนดเวลา

การกำหนดตารางเวลาให้สคริปต์ของคุณทำงานครั้งเดียวโดยใช้คำสั่ง at สามารถทำให้ชีวิตง่ายขึ้นในหลาย ๆ สถานการณ์ แต่ถ้าคุณต้องการเรียกใช้สคริปต์ในเวลาเดียวกันทุกวัน สัปดาห์ละครั้ง หรือเดือนละครั้งล่ะ

Linux มียูทิลิตี้ crontab ที่ให้คุณกำหนดเวลาสคริปต์ที่ต้องรันเป็นประจำ

Crontab ทำงานอยู่เบื้องหลัง และรันงานที่กำหนดเวลาไว้ตามข้อมูลที่เรียกว่าตาราง cron

หากต้องการดูตารางงาน cron ที่มีอยู่ ให้ใช้คำสั่งต่อไปนี้:

$ crontab –l
เมื่อกำหนดเวลาให้สคริปต์ทำงานตามกำหนดเวลา crontab จะยอมรับข้อมูลเกี่ยวกับเวลาที่จำเป็นต้องดำเนินการงานในรูปแบบต่อไปนี้:

นาที ชั่วโมง วันของเดือน เดือน วันในสัปดาห์
ตัวอย่างเช่น หากคุณต้องการให้สคริปต์ชื่อ command ถูกดำเนินการทุกวันเวลา 10:30 น. สิ่งนี้จะสอดคล้องกับรายการต่อไปนี้ในตารางงาน:

30 10 * * * คำสั่ง
ในที่นี้ ไวด์การ์ด "*" ที่ใช้สำหรับฟิลด์วันของเดือน เดือน และวันในสัปดาห์ ระบุว่า cron ควรรันคำสั่งทุกวันของทุกเดือน เวลา 10.30 น.

ตัวอย่างเช่น หากคุณต้องการให้สคริปต์ทำงานเวลา 16.30 น. ทุกวันจันทร์ คุณจะต้องสร้างรายการต่อไปนี้ในตารางงาน:

30 16 * * 1 คำสั่ง
การนับวันในสัปดาห์เริ่มจาก 0, 0 หมายถึงวันอาทิตย์, 6 หมายถึงวันเสาร์ นี่เป็นอีกตัวอย่างหนึ่ง ที่นี่คำสั่งจะถูกดำเนินการเวลา 12.00 น. ของวันแรกของทุกเดือน

00 12 1 * * คำสั่ง
เดือนมีเลขเริ่มต้นจาก 1
ในการเพิ่มรายการลงในตาราง คุณต้องเรียก crontab ด้วยสวิตช์ -e:

Crontab –e
จากนั้นคุณสามารถป้อนคำสั่งการสร้างกำหนดการได้:

30 10 * * * /home/likegeeks/Desktop/myscript
ด้วยคำสั่งนี้สคริปต์จะถูกเรียกทุกวันเวลา 10:30 น. หากคุณพบข้อผิดพลาด "ทรัพยากรไม่พร้อมใช้งานชั่วคราว" ให้รันคำสั่งด้านล่างในฐานะรูท:

$ rm -f /var/run/crond.pid
คุณสามารถจัดระเบียบการเปิดตัวสคริปต์เป็นระยะโดยใช้ cron ได้ง่ายยิ่งขึ้นโดยใช้ไดเร็กทอรีพิเศษหลายรายการ:

/etc/cron.hourly /etc/cron.daily /etc/cron.weekly /etc/cron.monthly
การวางไฟล์สคริปต์ไว้ในไฟล์ใดไฟล์หนึ่งจะทำให้ไฟล์ทำงานเป็นรายชั่วโมง รายวัน รายสัปดาห์ หรือรายเดือน ตามลำดับ

เรียกใช้สคริปต์เมื่อเข้าสู่ระบบและเริ่มต้นเชลล์

คุณสามารถเปิดใช้งานสคริปต์โดยอัตโนมัติตามเหตุการณ์ต่างๆ เช่น การเข้าสู่ระบบของผู้ใช้หรือการเปิดใช้งานเชลล์ คุณสามารถอ่านเกี่ยวกับไฟล์ที่ได้รับการประมวลผลในสถานการณ์ดังกล่าวได้ ตัวอย่างเช่น ไฟล์เหล่านี้เป็นไฟล์ต่อไปนี้:

$HOME/.bash_profile $HOME/.bash_login $HOME/.profile
หากต้องการเรียกใช้สคริปต์เมื่อเข้าสู่ระบบ ให้โทรออกในไฟล์ .bash_profile

แล้วการรันสคริปต์เมื่อคุณเปิดเทอร์มินัลล่ะ? ไฟล์ .bashrc จะช่วยคุณจัดระเบียบสิ่งนี้

ผลลัพธ์

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

เรียนผู้อ่าน! คุณใช้เครื่องมือเพื่อกำหนดเวลาสคริปต์บรรทัดคำสั่งให้ทำงานตามกำหนดเวลาหรือไม่? ถ้าใช่ โปรดบอกเราเกี่ยวกับพวกเขา

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

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

คำสั่ง & ชื่อสคริปต์ & /path/to/command arg1 arg2 & command-1 | คำสั่ง-2 arg1 & คำสั่ง-1 | command-2 -arg1 -arg2 >/path/to/output &

หากต้องการรันโปรแกรมในเบื้องหลังโดยไม่ปิดกั้นหน้าต่างเทอร์มินัล คุณต้องใช้ผู้สอนพิเศษ “&” วางอักขระนี้ไว้ที่ท้ายสุดของบรรทัดหลังจากระบุชื่อคำสั่ง ตัวเลือก และพารามิเตอร์อินพุต ใน ปริทัศน์ลำดับนี้สามารถป้อนเป็น “command_name -option input_parameter &”

ls ~/* > ~/test-file.txt &
18960

หลังจากกดปุ่ม Enter โปรแกรมจะเริ่มทำงานโดยอัตโนมัติในพื้นหลัง ในกรณีนี้ เทอร์มินัลจะแสดงบรรทัดที่มีเนื้อหา "[task_number] process_identifier" ต่อไปนี้ และจะแจ้งให้คุณป้อนคำสั่งที่สร้างขึ้นใหม่

ค้นหาคำสั่งที่ทำงานอยู่เบื้องหลังใน Linux

รันคำสั่งต่อไปนี้:

ตัวอย่างเอาต์พุตข้อมูล:

กำลังรัน find / -iname "*.c" 2> /dev/null > /tmp/output.txt &
+ การรัน grep -R "hostNamed" / 2> /dev/null > /tmp/grep.txt &

ตัวระบุคำสั่งซื้ออยู่ที่ไหน

หากต้องการแสดง ID กระบวนการสำหรับ ID งาน นอกเหนือจากการแคสต์มาตรฐาน ให้ส่งตัวเลือก -l:

ตัวอย่างเอาต์พุตข้อมูล:

7307 กำลังรันการค้นหา / -iname "*.c" 2> /dev/null > /tmp/output.txt &
+ 7324 การรัน grep -R "hostNamed" / 2> /dev/null > /tmp/grep.txt &

หากต้องการแสดงเฉพาะ ID กระบวนการ ให้ป้อน:

ตัวอย่างเอาต์พุตข้อมูล:

หยุดดำเนินการคำสั่งที่ทำงานอยู่เบื้องหลัง

หากต้องการยุติกระบวนการอย่างสง่างามหรือรุนแรง ให้ใช้คำสั่ง kill ไวยากรณ์มีดังนี้:

ฆ่าพีไอดี
ฆ่า -15 PID
ฆ่า -9 PID
กระบวนการ killall-ชื่อ-ที่นี่
killall -15 กระบวนการ-ชื่อ-ที่นี่
killall -9 กระบวนการ-ชื่อ-ที่นี่

การคืนโปรแกรมสู่โหมดเบื้องหน้าใน Linux

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

ค้นหา / -name .ini 2> ~/results.txt &
19090
เอฟจี 1
bash: fg: งานสิ้นสุดแล้ว
+ ออก 1 ค้นหา / -name .ini 2> ~/results.txt

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

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

โปรแกรมทั้งหมดสามารถแบ่งออกเป็นหลายประเภท:

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

ตอนนี้เรามาดูการเปิดตัวโปรแกรมกันดีกว่า

การรันโปรแกรมในเทอร์มินัล

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

/path/to/file/programตัวเลือก

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

นักพัฒนาได้คิดวิธีแก้ปัญหาแล้ว มีการสร้างตัวแปร PATH ซึ่งเก็บพาธทั้งหมดไปยังโฟลเดอร์ที่โปรแกรมมักจะอยู่ - /bin, /sbin, /usr/bin, /usr/sbin และอื่นๆ คุณสามารถดูเนื้อหาได้ด้วยคำสั่ง:

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

และคุณสามารถส่งพารามิเตอร์หลังช่องว่างได้:

เมื่อโปรแกรมไม่อยู่ในไดเร็กทอรีเหล่านี้ คุณต้องระบุเส้นทางแบบเต็ม:

/usr/local/bin/ls1

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

บางครั้งจำเป็นต้องถ่ายโอนสิ่งพิเศษบางอย่าง ตัวอย่างเช่น ตัวแปร EDITOR จะระบุว่าตัวแปรใด โปรแกรมแก้ไขข้อความควรจะใช้เป็นค่าเริ่มต้น คุณสามารถระบุชื่อตัวแปรและค่าของมันก่อนชื่อคำสั่งโดยใช้ไวยากรณ์:

Variable_name = คำสั่งค่า

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

EDITOR=ภาพนาโน

ตามค่าเริ่มต้น คำสั่งนี้จะเปิดการตั้งค่าในตัวแก้ไข Vim แต่ด้วยสิ่งนี้ ตัวแปรสภาพแวดล้อมการตั้งค่าจะเปิดขึ้นในตัวแก้ไขนาโน

การรันโปรแกรมในฐานะผู้ใช้รายอื่น

คุณรู้วิธีรันโปรแกรมแล้ว เทอร์มินัลลินุกซ์แล้วผู้ใช้รายอื่นล่ะ? ใน Windows เป็นเรื่องปกติที่จะเรียกใช้โปรแกรมในฐานะผู้ดูแลระบบ เพื่อให้โปรแกรมได้รับสิทธิ์การเข้าถึงในระบบมากขึ้น บน Linux จะใช้ยูทิลิตี้ sudo สำหรับสิ่งนี้ ชื่อของเธอสามารถถอดรหัสได้เป็น สแม่มด ยูเซอร์ ทำ- เปลี่ยนผู้ใช้และดำเนินการ ตามค่าเริ่มต้น ยูทิลิตีจะรันคำสั่งในฐานะ root superuser:

คำสั่ง sudo
ซูโดะ โฮอามิ

แต่การใช้ตัวเลือก -u คุณสามารถรันโปรแกรมได้เมื่อผู้ใช้เข้าสู่ระบบ:

คำสั่งชื่อผู้ใช้ sudo -u
sudo -u postgres whoami

คำสั่ง whoami (ฉันเป็นใคร) จะแสดงชื่อของผู้ใช้ปัจจุบัน

วิธีรันโปรแกรมในเบื้องหลัง

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

โปรแกรม_ชื่อ &

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

dd if=/dev/zero of=~/file count=100000 &

ระบบจะส่งออก PID ซึ่งเป็นตัวระบุเฉพาะของโปรแกรม ซึ่งคุณสามารถใช้เพื่อปิดได้:

วิธีรันสคริปต์บน Linux

เราได้กล่าวไปแล้วว่าโปรแกรมแบ่งออกเป็นไบนารี่และถูกตีความ ก่อนหน้านี้เราพูดถึงเฉพาะโปรแกรมไบนารี่เท่านั้น ในการรันโปรแกรมที่แปลแล้ว คุณต้องมีล่ามโดยตรง โปรแกรมดังกล่าวรวมถึงโปรแกรมที่เขียนด้วยภาษาต่างๆ เช่น Java, Python, Perl, Ruby, PHP, NodeJS และอื่นๆ อีกมากมาย ไวยากรณ์ในการเปิดโปรแกรมดังกล่าวแตกต่างออกไป:

ล่าม /path/to/file/programตัวเลือก

ล่ามที่ต่างกันมีพฤติกรรมแตกต่างกัน ดังนั้นจึงเป็นการดีกว่าที่จะระบุเส้นทางแบบเต็มไปยังโปรแกรมทันที Python มักจะรับสคริปต์จากโฟลเดอร์ปัจจุบันโดยไม่ระบุเส้นทางแบบเต็ม:

หลาม hellorld.py

และโปรแกรม Java จะต้องเปิดตัวในลักษณะนี้:

ชวา -jar โปรแกรม.jar

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

หรือเพียงพิมพ์เส้นทางไปยังสคริปต์:

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

sudo chmod u+x ./script.sh

ดังนั้น สำหรับโปรแกรมที่ถูกตีความส่วนใหญ่ สคริปต์ sh แบบง่ายได้ถูกสร้างขึ้นซึ่งสามารถเปิดใช้งานได้อย่างรวดเร็ว

การรันโปรแกรม Linux ใน GUI

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

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

การรันสคริปต์ใน อินเตอร์เฟซแบบกราฟิก. คุณสามารถค้นหาทางลัดเมนูทั้งหมดในไดเร็กทอรี /usr/share/applications/ สามารถเปิดโปรแกรมใดก็ได้โดยดับเบิลคลิกจากที่นี่ แต่มาดูกันว่ามีอะไรอยู่ในทางลัด หากต้องการทำสิ่งนี้ ให้เปิดในโปรแกรมแก้ไขข้อความ:

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

ข้อสรุป

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