$ นอน 100 &[1] 9298
ใช้
พิดอฟคุณสามารถดูรหัสกระบวนการของชื่อโปรแกรมที่ระบุได้:
$ pidof sleep9298
$ cat /proc/9298/maps08048000-0804b000 r-xp 00000000 08:01 977399 /bin/sleep0804b000-0804c000 rw -p 00003000 08:01 977399 /bin/sleep0804c000-0806d000 rw-p 0804c000 00:00 0 [ฮีป]b7c8b000-b7cca000 r--p 00000000 08:01 443354...bfbd8000-bfbed000 rw-p bfbd8000 00:00 0 [สแต็ค]ffffe000-fffff000 r-xp 00000000 00:00 0 [vdso]
หลังจากรันโปรแกรมแล้ว โปรแกรมจะถูกโหลดเข้าสู่หน่วยความจำและกลายเป็นกระบวนการ ภาพด้านบนแสดงอิมเมจหน่วยความจำ (หน่วยความจำเสมือน) ของกระบวนการ รวมถึงคำสั่งโปรแกรม ข้อมูล และพื้นที่สแต็กบางส่วนที่ใช้ในการจัดเก็บพารามิเตอร์บรรทัดคำสั่งของโปรแกรมและตัวแปรสภาพแวดล้อม ได้รับการจัดสรรพื้นที่ฮีปที่ใช้สำหรับแอปพลิเคชันหน่วยความจำแบบไดนามิก
สำหรับรายละเอียดเกี่ยวกับกระบวนการรันโปรแกรมบนบรรทัดคำสั่ง โปรดดูที่ "ช่วงเวลาของการรันโปรแกรมภายใต้บรรทัดคำสั่ง Linux"
ที่จริงแล้ว มีวิธีอื่นในการสร้างกระบวนการ กล่าวคือ เพื่อให้โปรแกรมทำงาน ตัวอย่างเช่น คุณสามารถเริ่มโปรแกรมโดยอัตโนมัติเมื่อระบบเริ่มทำงานผ่านการกำหนดค่าบางอย่าง (สำหรับรายละเอียด โปรดดูที่
ผู้ชายเริ่มต้น) หรือโดยการกำหนดค่า
ครอนด์(หรือ
ที่) เพื่อให้โปรแกรมเริ่มทำงานอย่างสม่ำเสมอ นอกจากนี้ยังมีอีกวิธีหนึ่งคือเขียนเชลล์สคริปต์และเขียนโปรแกรมลงในไฟล์สคริปต์ เมื่อไฟล์สคริปต์ถูกเรียกใช้งาน โปรแกรมในไฟล์จะถูกดำเนินการและกลายเป็นกระบวนการ รายละเอียดของวิธีการเหล่านี้จะไม่ถูกนำมาใช้ มาเรียนรู้วิธีดูคุณสมบัติของกระบวนการกันดีกว่า
สิ่งหนึ่งที่ต้องเพิ่มคือ: คุณสามารถดำเนินการโปรแกรมภายใต้บรรทัดคำสั่งได้
ยูลิมิตคำสั่งในตัวใช้เพื่อตั้งค่าทรัพยากรที่กระบวนการสามารถใช้ได้ เช่น จำนวนตัวอธิบายไฟล์สูงสุดที่กระบวนการสามารถเปิดได้ พื้นที่สแต็กสูงสุด พื้นที่หน่วยความจำเสมือน ฯลฯ สำหรับการใช้งานเฉพาะ โปรดดู
ความช่วยเหลือจำกัด-
สามารถผ่านไปได้
ป.ลใช้คำสั่งเพื่อดูแอ็ตทริบิวต์และสถานะที่เกี่ยวข้องกับกระบวนการ ข้อมูลนี้รวมถึงผู้ใช้ที่เป็นเจ้าของกระบวนการ โปรแกรมที่สอดคล้องกับกระบวนการ และ
ซีพียูและการใช้หน่วยความจำและข้อมูลอื่นๆ ความคุ้นเคยกับวิธีดูข้อมูลเหล่านี้สามารถช่วยในการวิเคราะห์ทางสถิติที่เกี่ยวข้องและการดำเนินการอื่นๆ ได้
ดูคุณสมบัติของกระบวนการปัจจุบันทั้งหมดในระบบ:
$ปล.-ef
ดูกระบวนการที่สอดคล้องกับโปรแกรมที่มีอักขระบางตัวในคำสั่ง กระบวนการ
บัตรประจำตัวประชาชนคือ 1
ทีทีวายสำหรับ? บ่งชี้ว่ามันไม่เกี่ยวข้องกับเทอร์มินัล:
$ PS -C เริ่มต้น PID TTY TIME CMD 1 ?
เลือกกระบวนการที่เริ่มต้นโดยผู้ใช้เฉพาะ:
$ PS -U เหยี่ยว
ส่งออกเนื้อหาที่ระบุตามรูปแบบที่ระบุ ต่อไปนี้จะแสดงชื่อคำสั่งและ
ซีพียูอัตราการใช้งาน:
$ PS -e -o %C %c
พิมพ์
ซีพียูโปรแกรมที่ใช้มากที่สุด 4 อันดับแรก:
$ ps -e -o %C %c |. sort -u -k1 -r |. head -5 7.5 firefox-bin 1.1 Xorg 0.8 scim-panel-gtk 0.2 scim-บริดจ์
รับห้ากระบวนการโดยใช้หน่วยความจำเสมือนที่ใหญ่ที่สุด:
$ ps -e -o %z %c |. sort -n -k1 -r |. head -5349588 firefox-bin 96612 xfce4-terminal 88840 xfdesktop 76332 gedit 58920 scim-panel-gtk
มีความสัมพันธ์แบบ "เครือญาติ" ระหว่างกระบวนการทั้งหมดในระบบซึ่งสามารถเป็นได้
เพรสทรีตรวจสอบความสัมพันธ์นี้:
$ เพรสทรี
แผนผังการเรียกกระบวนการของระบบจะถูกพิมพ์ไว้ด้านบน และคุณสามารถเห็นความสัมพันธ์การเรียกระหว่างกระบวนการที่ทำงานอยู่ทั้งหมดในระบบปัจจุบันได้อย่างชัดเจน
$ ด้านบน
คุณสมบัติที่ใหญ่ที่สุดของคำสั่งนี้คือสามารถดูข้อมูลกระบวนการแบบไดนามิกได้ แน่นอนว่ายังมีพารามิเตอร์อื่นๆ บางอย่างด้วย เช่น
-สคุณสามารถจัดเรียงและดูตามเวลาดำเนินการสะสม หรือคุณสามารถใช้ก็ได้
-คุณดูกระบวนการที่เริ่มต้นโดยผู้ใช้ที่ระบุ ฯลฯ
เติมเงิน:
สูงสุดคำสั่งรองรับการโต้ตอบ เช่น รองรับ
คุณคำสั่งแสดงกระบวนการทั้งหมดของผู้ใช้และรองรับการส่งผ่าน
เคคำสั่งให้ฆ่ากระบวนการ หากใช้
-n 1ตัวเลือกในการเปิดใช้งานโหมดการประมวลผลแบบแบตช์ การใช้งานเฉพาะคือ:
$ ด้านบน -n 1 -b
เรามาหารือเกี่ยวกับปัญหาที่น่าสนใจ: วิธีทำให้โปรแกรมทำงานเพียงโปรแกรมเดียวในเวลาเดียวกัน
ซึ่งหมายความว่าในขณะที่โปรแกรมกำลังดำเนินการอยู่นั้น จะไม่สามารถเริ่มต้นใหม่ได้อีก แล้วต้องทำอย่างไร?
หากโปรแกรมเดียวกันถูกคัดลอกเป็นหลายชุดและมีชื่อไฟล์ต่างกันและถูกวางไว้ในตำแหน่งที่แตกต่างกัน สิ่งนี้จะแย่กว่านั้น ดังนั้นให้พิจารณากรณีที่ง่ายที่สุด นั่นคือ โปรแกรมนี้มีเอกลักษณ์เฉพาะในทั้งระบบ และชื่อก็ไม่ซ้ำกันด้วย . ในกรณีนี้ มีวิธีใดบ้างที่จะตอบคำถามข้างต้นได้
กลไกทั่วไปคือ: ตรวจสอบที่จุดเริ่มต้นของโปรแกรมว่ามีการดำเนินการหรือไม่ หากมีการดำเนินการ ให้หยุด หรือดำเนินการโค้ดถัดไปต่อไป
กลยุทธ์มีความหลากหลาย เนื่องจากสมมติฐานก่อนหน้านี้ทำให้มั่นใจถึงความเป็นเอกลักษณ์ของชื่อไฟล์และรหัสของโปรแกรม
ป.ลคำสั่งค้นหาชื่อโปรแกรมที่สอดคล้องกับกระบวนการปัจจุบันทั้งหมด และเปรียบเทียบกับชื่อโปรแกรมของตัวเองทีละชื่อ ถ้ามีอยู่แล้ว แสดงว่ามันถูกรันแล้ว
ps -e -o %c |. tr -d |. grep -q ^init$ #ตรวจสอบว่าโปรแกรมปัจจุบันถูกดำเนินการหรือไม่ [ $? -eq 0 ] && exit #If is, then exit, $? ถูกดำเนินการเรียบร้อยแล้ว
แต่ละครั้งที่ทำงาน ให้ตรวจสอบก่อนว่ามีกระบวนการที่บันทึกตัวเองไว้ที่ตำแหน่งที่ระบุหรือไม่
บัตรประจำตัวประชาชนหากไม่มีอยู่ ให้ดำเนินการดำเนินการต่อไป หากมี จากนั้นจึงดูกระบวนการ
บัตรประจำตัวประชาชนมันกำลังทำงานอยู่หรือไม่ ถ้าเป็นเช่นนั้น ให้ออก หรือเขียนกระบวนการใหม่ลงในไฟล์
บัตรประจำตัวประชาชนและดำเนินการต่อ
pidfile=/tmp/$0.pidif [ -f $pidfile ]; จากนั้น OLDPID=$(cat $pidfile) ps -e -o %p |. tr -d |. grep -q ^$OLDPID$ [ $? -eq 0 ] && exitfiecho $$ > $pidfile#... Code body# ตั้งค่าการทำงานของสัญญาณ 0 เมื่อโปรแกรมออก สัญญาณจะถูกกระตุ้นให้ลบไฟล์ชั่วคราว trap rm $pidfile 0
คุณสามารถใช้กลยุทธ์การนำไปปฏิบัติเพิ่มเติมได้ด้วยตนเอง!
นอกเหนือจากการรับรองว่าแต่ละกระบวนการสามารถดำเนินการได้อย่างราบรื่น เพื่อให้งานบางอย่างเสร็จสมบูรณ์ก่อน ระบบจะใช้วิธีการจัดกำหนดการบางอย่างเมื่อกระบวนการจัดกำหนดการ เช่น อัลกอริธึมการจัดกำหนดการทั่วไปของการหมุนส่วนของเวลาตามลำดับความสำคัญ ในกรณีนี้คุณสามารถผ่านได้
เรไนซ์ปรับลำดับความสำคัญของโปรแกรมที่กำลังรันอยู่ เช่น: `
$ PS -e -o %p %c %n |. grep xfs 5089 xfs 0
$ renice 1 -p 5089renice: 5089: setpriority: ไม่อนุญาตให้ดำเนินการ$ sudo renice 1 -p 5089 #Permissions are required [sudo] รหัสผ่านสำหรับ falcon:5089: ลำดับความสำคัญเก่า 0, ลำดับความสำคัญใหม่ 1$ ps -e -o %p % c %n |. grep xfs #ดูอีกครั้ง ลำดับความสำคัญได้รับการปรับแล้ว 5089 xfs 1
เนื่องจากคุณสามารถรันโปรแกรมและสร้างกระบวนการผ่านบรรทัดคำสั่งได้ จึงมีวิธียุติกระบวนการด้วย สามารถผ่านไปได้
ฆ่าคำสั่งจะส่งสัญญาณไปยังกระบวนการที่ผู้ใช้เริ่มต้นเพื่อยุติกระบวนการ แน่นอนว่ามันเป็น "สากล"
รากเกือบ
ฆ่ากระบวนการทั้งหมด (ยกเว้น
เริ่มต้นข้างนอก). ตัวอย่างเช่น,
$ sleep 50 & #Start กระบวนการ [1] 11347$ ฆ่า 11347
ฆ่าคำสั่งจะส่งสัญญาณการสิ้นสุดตามค่าเริ่มต้น (
เครื่องหมาย) เข้าสู่โปรแกรมแล้วปล่อยให้โปรแกรมออกจากโปรแกรมแต่
ฆ่าสัญญาณอื่นๆ ก็สามารถส่งสัญญาณได้และสามารถกำหนดได้ผ่านทาง
สัญญาณคนที่ 7คุณยังสามารถดูได้ผ่าน
ฆ่า -lออกรายการเลย
$ ชาย 7 สัญญาณ $ ฆ่า -l 1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL 5) SIGTRAP 6) SIGABRT 7) SIGBUS 8) SIGFPE 9) SIGKILL 10) SIGUSR1 11) SIGSEGV 12) SIGUSR213) SIGPIPE 14) SIGALRM 15 ) เครื่องหมาย 16) SIGSTKFLT17) SIGCHLD 18) SIGCONT 19) SIGSTOP 20) SIGTSTP21) SIGTTIN 22) SIGTTOU 23) SIGURG 24) SIGXCPU25) SIGXFSZ 26) SIGVTALRM 27) SIGPROF 28) SIGWINCH29) SIGIO 30) SIGPWR 31) SIGSYS 34) SIGRTMIN35) SIGRTMIN+1 36) SIGRTMIN+2 37) SIGRTMIN+3 38) SIGRTMIN+439) SIGRTMIN+5 40) SIGRTMIN+6 41) SIGRTMIN+7 42) SIGRTMIN+843) SIGRTMIN+9 44) ซิกRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+1247) SIGRTMIN+13 48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-1451) SIGRTMAX-13 52) SIGRTMAX-12 53) SIGRTMAX-11 54) SIGRTMAX-1055) SIGRTMAX-9 56) SIGRTMAX-8 57) SIGRTMAX-7 58) SIGRTMAX-659) SIGRTMAX-5 60) SIGRTMAX-4 61) SIGRTMAX-3 62) SIGRTMAX-263) SIGRTMAX-1 64) SIGRTMAX
ตัวอย่างเช่น ใช้
ฆ่าคำสั่งให้ส่ง
ซิกสต็อปส่งสัญญาณให้โปรแกรมหยุดชั่วคราวแล้วส่ง
ซิกคอนต์สัญญาณยังคงทำงานต่อไป
$ sleep 50 &[1] 11441$ งาน[1]+ การรัน sleep 50 &$ kill -s SIGSTOP 11441 #นี่เทียบเท่ากับการที่เราทำการดำเนินการ CTRL+Z บนกระบวนการเบื้องหน้า $ งาน[1]+ หยุดการนอนหลับ 50$ kill - s SIGCONT 11441 #นี่เทียบเท่ากับการดำเนินการ bg %1 ก่อนหน้าที่เราใช้ในการรันกระบวนการเบื้องหลัง $ jobs[1]+ การรัน sleep 50 &$ kill %1 #ภายใต้เซสชันปัจจุบัน คุณยังสามารถควบคุมกระบวนการผ่านหมายเลขงาน $ jobs[1]+ ยุติโหมดสลีป 50
มองเห็นได้
ฆ่าคำสั่งจัดเตรียมฟังก์ชันที่ดีมาก แต่จะขึ้นอยู่กับกระบวนการเท่านั้น
บัตรประจำตัวประชาชนหรืองานควบคุมกระบวนการในขณะนั้น
ฆ่าและ
คิลออลมีตัวเลือกเพิ่มเติมที่ขยายวิธีการควบคุมกระบวนการตามชื่อโปรแกรมหรือแม้แต่ชื่อผู้ใช้ โปรดดูคู่มือของพวกเขาสำหรับการใช้งานเพิ่มเติม
เมื่อโปรแกรมออก จะทราบได้อย่างไรว่าโปรแกรมออกจากปกติหรือผิดปกติ? ยังจำคลาสสิกนั้นภายใต้ Linux ได้ไหม?
สวัสดีชาวโลกโปรแกรม? ที่ส่วนท้ายของโค้ดจะมีบรรทัดอยู่เสมอ
กลับ 0คำแถลง. นี้
กลับ 0มันช่วยให้โปรแกรมเมอร์ตรวจสอบว่ากระบวนการออกจากปกติหรือไม่ หากกระบวนการส่งคืนค่าที่แตกต่างออกไป ก็อาจกล่าวได้อย่างปลอดภัยว่ากระบวนการออกจากการทำงานอย่างผิดปกติเนื่องจากยังไม่ได้ดำเนินการ
กลับ 0คำสั่งนี้ออก
แล้วจะตรวจสอบสถานะการออกของกระบวนการได้อย่างไรนั่นคือค่าที่ส่งคืน?
มีอยู่
เปลือกคุณสามารถตรวจสอบตัวแปรพิเศษนี้ได้
-ซึ่งเก็บสถานะการออกหลังจากดำเนินการคำสั่งก่อนหน้า
$ test1bash: test1: ไม่พบคำสั่ง$ echo $?127$ cat ./test.c | grep hello$ echo $?1$ cat ./test.c |. grep hi printf(สวัสดี, ตัวเอง!n);$ echo $?0
ดูเหมือนว่าการส่งคืน 0 กลายเป็นกฎที่ไม่ได้พูด แม้ว่าจะไม่มีมาตรฐานกำหนดไว้อย่างชัดเจน แต่เมื่อโปรแกรมส่งคืนตามปกติก็สามารถส่งคืนได้เสมอ
-ตรวจพบ 0 ใน แต่เมื่อผิดปกติ ค่าที่ไม่ใช่ 0 จะถูกตรวจพบเสมอ สิ่งนี้บอกเราว่าเมื่อสิ้นสุดโปรแกรม วิธีที่ดีที่สุดคือปฏิบัติตาม
ทางออก 0เพื่อให้ทุกคนสามารถผ่านการทดสอบได้
-ตรวจสอบว่าโปรแกรมสิ้นสุดตามปกติหรือไม่ หากวันหนึ่งมีคนใช้โปรแกรมของคุณเป็นครั้งคราวและพยายามตรวจสอบสถานะการออก แต่คุณกลับคืนมาอย่างอธิบายไม่ได้
-1หรือ 1 เขาจะลำบากใจมากและจะสงสัยว่าปัญหาอยู่ที่ไหนในโปรแกรมที่เขาเขียนเอง เขาจะตรวจสอบมันเป็นเวลานานแต่กลับพ่ายแพ้เพราะเขาเชื่อใจคุณมากจนไม่เคยสงสัยในนิสัยการเขียนโปรแกรมของคุณเลย เริ่มที่จะสิ้นสุด มันจะแตกต่าง!
เพื่ออำนวยความสะดวกในการออกแบบและการใช้งาน งานขนาดใหญ่มักถูกแบ่งออกเป็นโมดูลขนาดเล็ก โมดูลต่างๆ กลายเป็นกระบวนการหลังจากที่เริ่มต้นแล้ว พวกเขาสื่อสารกันเพื่อแลกเปลี่ยนข้อมูลและทำงานร่วมกันได้อย่างไร มีกล่าวถึงวิธีการต่างๆ มากมายในหนังสือ "Advanced Programming in UNIX Environment" เช่น ไปป์ (ไปป์ที่ไม่มีชื่อและไปป์ที่มีชื่อ) สัญญาณ (
สัญญาณ), ข้อความ (
ข้อความ) คิว (คิวข้อความ) หน่วยความจำที่ใช้ร่วมกัน (
mmap/munmap), เซมาฟอร์ (
สัญญาณส่วนใหญ่ใช้สำหรับการซิงโครไนซ์ระหว่างกระบวนการระหว่างเธรดที่แตกต่างกันของกระบวนการ) ซ็อกเก็ต (
ซ็อกเก็ต, รองรับการสื่อสารกระบวนการระหว่างเครื่องจักรที่แตกต่างกัน) ฯลฯ และในเชลล์ ท่อและสัญญาณมักจะถูกใช้โดยตรง ต่อไปนี้จะแนะนำการใช้ไปป์และกลไกสัญญาณในการเขียนโปรแกรมเชลล์เป็นหลัก
ภายใต้ Linux คุณสามารถผ่านได้
-เชื่อมต่อสองโปรแกรมเข้าด้วยกันเพื่อให้คุณสามารถใช้เชื่อมต่ออินพุตของโปรแกรมหลังกับเอาต์พุตของโปรแกรมก่อนหน้าได้ จึงเรียกว่าไพพ์อย่างชัดเจน ในภาษา C การสร้างไปป์ที่ไม่มีชื่อนั้นง่ายและสะดวกมาก
ท่อฟังก์ชันส่งผ่านในสององค์ประกอบ
ภายในอาร์เรย์ของประเภทจะทำ อาร์เรย์นี้เก็บตัวอธิบายไฟล์สองตัวจริง ๆ หลังจากที่กระบวนการหลักเขียนบางอย่างไปยังตัวอธิบายไฟล์ตัวแรก กระบวนการลูกสามารถอ่านได้จากตัวอธิบายไฟล์ตัวแรก
หากคุณใช้บรรทัดคำสั่งมากเกินไป ไปป์นี้
-ควรใช้บ่อยๆ เช่น มีการสาธิตด้านบน
ป.ลผลลัพธ์ของคำสั่งจะเป็นดังนี้
เกรปอินพุตคำสั่ง:
$ PS -ef | .grep เริ่มต้น
คุณอาจคิดว่า "ไพพ์" นี้วิเศษมากจนสามารถเชื่อมโยงอินพุตและเอาท์พุตของสองโปรแกรมได้จริง ในความเป็นจริง เมื่อป้อนชุดคำสั่งดังกล่าว เชลล์ปัจจุบันจะดำเนินการแยกวิเคราะห์ที่เหมาะสม เชื่อมโยงเอาต์พุตของกระบวนการก่อนหน้ากับตัวอธิบายไฟล์เอาต์พุตของไปป์ และเชื่อมโยงอินพุตของกระบวนการต่อมากับตัวอธิบายไฟล์อินพุตของ ไปป์ กระบวนการเชื่อมโยงนี้เปลี่ยนเส้นทางผ่านอินพุตและเอาต์พุต
ซ้ำซ้อน(หรือ
fcntl) เพื่อให้บรรลุ
ไปป์ที่มีชื่อจริง ๆ แล้วเป็นไฟล์ (ไปป์ที่ไม่มีชื่อก็เหมือนกับไฟล์ แม้ว่าจะเกี่ยวข้องกับตัวอธิบายไฟล์สองตัว แต่ก็สามารถอ่านได้ด้านเดียวและเขียนอีกด้านหนึ่ง) อย่างไรก็ตาม ไฟล์นี้ค่อนข้างพิเศษ ต้องเป็นไปตามการเข้าก่อนออกก่อนระหว่างการดำเนินการ และหากคุณพยายามอ่านจากไปป์ที่มีชื่อซึ่งไม่มีเนื้อหา คุณจะถูกบล็อก ในทำนองเดียวกัน หากคุณพยายามเขียนไปยังไปป์ที่มีชื่อและไม่มีโปรแกรมใดกำลังพยายามอยู่ หากต้องการอ่าน คุณจะถูกบล็อก ดูผลกระทบด้านล่าง
$ mkfifo fifo_test #สร้างไปป์ที่มีชื่อเสียงผ่านคำสั่ง mkfifo $ echo littlefefe > fifo_test #กำลังพยายามเขียนเนื้อหาลงในไฟล์ fifo_test แต่มันถูกบล็อก คุณต้องเปิดเทอร์มินัลอื่นเพื่อดำเนินการต่อไปนี้ต่อไป $ cat fifo_test #เปิดเทอร์มินัลอื่น จำไว้ว่าให้เปิดอันอื่น กำลังพยายามอ่านเนื้อหาของ fifo_test littlefefe
นี่.
เสียงสะท้อนและ
แมวเป็นสองโปรแกรมที่แตกต่างกันในกรณีนี้คือโดย
เสียงสะท้อนและ
แมวไม่มีความสัมพันธ์ระหว่างแม่และลูกระหว่างกระบวนการที่เริ่มต้นทั้งสอง อย่างไรก็ตาม พวกเขายังสามารถสื่อสารผ่านไปป์ที่มีชื่อได้
วิธีการสื่อสารดังกล่าวเหมาะสมมากสำหรับบางสถานการณ์ เช่น มีสถาปัตยกรรมดังกล่าว สถาปัตยกรรมนี้ประกอบด้วยสองแอปพลิเคชัน โดยแอปพลิเคชันหนึ่งจะอ่านผ่านลูปอย่างต่อเนื่อง
fifo_testเนื้อหาเพื่อกำหนดว่าควรทำอย่างไรต่อไป หากไปป์นี้ไม่มีเนื้อหา ก็จะถูกบล็อกที่นั่นโดยไม่ต้องใช้ทรัพยากรเนื่องจากการวนซ้ำไม่สิ้นสุด ส่วนอีกอันจะยังคงไหลต่อไปเป็นโปรแกรมควบคุม
fifo_testเขียนข้อมูลการควบคุมลงไปเพื่อบอกโปรแกรมก่อนหน้าว่าต้องทำอะไร เขียนตัวอย่างง่ายๆ ด้านล่าง คุณสามารถออกแบบโค้ดควบคุมบางส่วนได้ จากนั้นโปรแกรมควบคุมจะดำเนินต่อไป
fifo_testเขียนลงไป จากนั้นแอปพลิเคชันจะดำเนินการต่างๆ ให้เสร็จสิ้นตามรหัสควบคุมเหล่านี้ แน่นอนคุณยังสามารถไปที่
fifo_testส่งผ่านข้อมูลอื่นยกเว้นรหัสควบคุม
รหัสแอปพลิเคชัน
$ cat app.sh #!/bin/bash FIFO=fifo_test while :; do CI=`cat $FIFO` #CI --> กรณีข้อมูลการควบคุม $CI ใน 0) echo หมายเลข CONTROL คือ ZERO, do something ... ;; 1) echo หมายเลข CONTROL คือ ONE, do something ... ;;
รหัสโปรแกรมควบคุม
$ cat control.sh #!/bin/bash FIFO=fifo_test CI=$1 [ -z $CI ] && echo ข้อมูลการควบคุมไม่ควรว่างเปล่า && exit echo $CI > $FIFO
โปรแกรมหนึ่งควบคุมการทำงานของอีกโปรแกรมหนึ่งผ่านไพพ์
$ chmod +x app.sh control.sh #แก้ไขสิทธิ์ปฏิบัติการของทั้งสองโปรแกรมนี้เพื่อให้ผู้ใช้สามารถดำเนินการได้ $ ./app.sh #เริ่มแอปพลิเคชันนี้ในเทอร์มินัลและส่งการควบคุมผ่าน ./control.sh ตรวจสอบเอาต์พุต หลังรหัส หมายเลข CONTROL คือ ONE ให้ทำอย่างอื่น... #หลังจากส่ง 1 หมายเลข CONTROL เป็นศูนย์ ให้ทำอะไรบางอย่าง... #หลังจากส่ง 0 ไม่รู้จักหมายเลข CONTROL ให้ทำอย่างอื่น... #ส่งสิ่งที่ไม่รู้จัก หลังจากโค้ดควบคุม $ ./control.sh 1 #ในเทอร์มินัลอื่น ส่งข้อมูลการควบคุมเพื่อควบคุมการทำงานของแอปพลิเคชัน $ ./control.sh 0 $ ./control.sh 4343
สถาปัตยกรรมแอปพลิเคชันดังกล่าวเหมาะมากสำหรับการออกแบบงานหลายโปรแกรมในพื้นที่
เว็บซีจีไอจากนั้นจะเหมาะกับข้อกำหนดของรีโมทคอนโทรลด้วย แนะนำ
เว็บซีจีไอการเปลี่ยนแปลงเพียงอย่างเดียวคือโปรแกรมควบคุม
./control.shใส่ใน
เว็บของ
ซีจีไอไดเร็กทอรีและทำการแก้ไขบางอย่างเพื่อให้สอดคล้อง
ซีจีไอข้อกำหนดซึ่งรวมถึงการแสดงรูปแบบเอาต์พุตเอกสาร (จำเป็นต้องเอาต์พุตที่จุดเริ่มต้นของไฟล์
ประเภทเนื้อหา: text/htmlและบรรทัดว่าง) และการได้มาของพารามิเตอร์อินพุต
(เว็บพารามิเตอร์อินพุตจะถูกเก็บไว้ใน
QUERY_STRINGตัวแปรสภาพแวดล้อม) ดังนั้นง่ายมาก
ซีจีไอโปรแกรมควบคุมสามารถเขียนได้ดังนี้:
#!/bin/bashFIFO=./fifo_testCI=$QUERY_STRING[ -z $CI ] && echo ข้อมูลการควบคุมไม่ควรว่างเปล่า && exitecho -e content-type: text/htmlnnecho $CI > $FIFO
ในการใช้งานจริงโปรดตรวจสอบให้แน่ใจ
ควบคุม.shสามารถเข้าถึงได้
fifo_testไปป์และมีสิทธิ์เขียนเพื่อควบคุมผ่านเบราว์เซอร์
แอพ.ช-
http://ipaddress_or_dns/cgi-bin/control.sh?0
เครื่องหมายคำถาม
-โดยมีเนื้อหาดังต่อไปนี้
QUERY_STRINGคล้ายกับครั้งก่อน
$1-
แอปพลิเคชันดังกล่าวมีความสำคัญในทางปฏิบัติอย่างมากสำหรับการควบคุมระยะไกล โดยเฉพาะการควบคุมระยะไกลของระบบฝังตัว ในหลักสูตรภาคฤดูร้อนของปีที่แล้ว เราใช้การควบคุมระยะไกลของมอเตอร์ในลักษณะนี้ ขั้นแรก มีการใช้แอปพลิเคชันง่ายๆ เพื่อควบคุมการหมุนของมอเตอร์ รวมถึงการควบคุมความเร็ว ทิศทาง ฯลฯ เพื่อให้บรรลุการควบคุมระยะไกล เราได้ออกแบบรหัสควบคุมบางอย่างเพื่อควบคุมคุณสมบัติต่างๆ ที่เกี่ยวข้องกับการหมุนของมอเตอร์
ในภาษา C หากคุณต้องการใช้เนมไปป์ก็จะคล้ายกับเชลล์ ยกเว้นว่าเมื่ออ่านและเขียนข้อมูลให้ใช้
อ่าน-
เขียนโทรสร้าง
ฟิโฟใช้เมื่อ
เอ็มเคฟิโฟการเรียกใช้ฟังก์ชัน
สัญญาณคือการขัดจังหวะของซอฟต์แวร์ที่ผู้ใช้ Linux สามารถเข้าถึงได้ผ่าน
ฆ่าคำสั่งจะส่งสัญญาณเฉพาะไปยังกระบวนการหรือสัญญาณบางอย่างสามารถส่งสัญญาณผ่านแป้นพิมพ์ได้ เช่น
CTRL+ซีอาจกระตุ้น
SGIINTสัญญาณในขณะที่
CTRL+อาจกระตุ้น
สกิควิทสัญญาณ เป็นต้น นอกจากนี้เคอร์เนลยังจะส่งสัญญาณไปยังกระบวนการภายใต้สถานการณ์บางอย่าง เช่น เมื่อเข้าถึงหน่วยความจำนอกขอบเขต
SGISEGVแน่นอนว่าสัญญาณและกระบวนการเองก็สามารถผ่านได้เช่นกัน
ฆ่า-
ยกรอให้ฟังก์ชันส่งสัญญาณถึงตัวเอง สำหรับประเภทสัญญาณที่รองรับบน Linux คุณสามารถผ่านได้
สัญญาณคนที่ 7หรือ
ฆ่า -lดูรายการและคำแนะนำที่เกี่ยวข้อง
สำหรับสัญญาณบางอย่าง กระบวนการจะมีการดำเนินการตอบสนองเริ่มต้น ในขณะที่สัญญาณบางอย่าง กระบวนการอาจเพิกเฉยต่อสัญญาณเหล่านั้นได้ แน่นอนว่าผู้ใช้ยังสามารถตั้งค่าฟังก์ชันการประมวลผลพิเศษสำหรับสัญญาณบางอย่างได้ ในเปลือกก็ผ่านได้
กับดักคำสั่ง (คำสั่งในตัวของเชลล์) เพื่อตั้งค่าการดำเนินการเพื่อตอบสนองต่อสัญญาณ (คำสั่งหรือฟังก์ชันที่กำหนด) และในภาษา C คุณสามารถใช้
สัญญาณเรียกใช้ฟังก์ชันตัวจัดการที่ลงทะเบียนไว้สำหรับสัญญาณ นี่เป็นเพียงการสาธิต
กับดักการใช้คำสั่ง.
$ function signal_handler { echo hello, world.; } #Define the signal_handler function $ trap signal_handler SIGINT #ดำเนินการตั้งค่าคำสั่งนี้: พิมพ์สวัสดี world เมื่อได้รับสัญญาณ SIGINT $ hello, world #กด CTRL+C เพื่อดูหน้าจอ สวัสดี และสตริงโลกจะถูกส่งออกในทำนองเดียวกัน หากคุณตั้งค่าการตอบสนองของสัญญาณ 0 คุณสามารถใช้ได้
กับดักเพื่อจำลองโปรแกรมภาษาซี
ออกไปการลงทะเบียนฟังก์ชั่นการยกเลิกโปรแกรมนั่นคือผ่าน
กับดัก signal_handler SIGQUITชุด
signal_handlerฟังก์ชั่นจะถูกดำเนินการเมื่อโปรแกรมออก สัญญาณ 0 เป็นสัญญาณพิเศษเข้า
POSIX.1สัญญาณหมายเลข 0 ถูกกำหนดให้เป็นสัญญาณว่าง ซึ่งมักใช้เพื่อพิจารณาว่ากระบวนการเฉพาะยังคงมีอยู่หรือไม่ สัญญาณนี้จะถูกทริกเกอร์เมื่อโปรแกรมออก
$ cat sigexit.sh#!/bin/bashfunction signal_handler { echo hello, world}trap signal_handler 0$ chmod +x sigexit.sh$ ./sigexit.sh #การเขียนโปรแกรม Shell จริงจะใช้วิธีนี้เพื่อทำการล้างข้อมูลเมื่อโปรแกรมออก จบการทำงานไฟล์ชั่วคราว สวัสดีชาวโลกเมื่อเราส่งคำสั่งหลายคำสั่งผ่าน
-เมื่อรวมเข้าด้วยกัน ลำดับคำสั่งนี้มักจะเริ่มกระบวนการต่างๆ ที่สื่อสารผ่านไพพ์ ฯลฯ บางครั้งเมื่อดำเนินการงาน มีงานอื่น ๆ ที่ต้องดำเนินการ ดังนั้นคุณมักจะเพิ่ม & ที่ท้ายลำดับคำสั่ง หรือหลังจากดำเนินการคำสั่ง ให้กด
CTRL+Zทำให้คำสั่งก่อนหน้าหยุดชั่วคราว เพื่อไปทำงานอื่นๆ หลังจากทำงานอื่นเสร็จแล้วก็ผ่านไป
ฉคำสั่งสลับงานพื้นหลังเป็นเบื้องหน้า กระบวนการควบคุมดังกล่าวมักเรียกว่าการควบคุมงาน และลำดับคำสั่งเหล่านั้นเรียกว่างาน งานนี้อาจเกี่ยวข้องกับหนึ่งหรือหลายโปรแกรม หนึ่งหรือหลายกระบวนการ ข้อมูลต่อไปนี้สาธิตการดำเนินการควบคุมงานที่ใช้กันทั่วไปหลายอย่าง
$ นอน 50 และ[1] 11137
ใช้คำสั่งในตัวของเชลล์
ฉนำงาน 1 ไปเบื้องหน้าแล้วกด
CTRL+Zหยุดกระบวนการชั่วคราว
$ fg %1sleep 50^Z[1]+ หยุดการนอนหลับ 50
$ งาน # ตรวจสอบสถานะงานปัจจุบัน งานหนึ่งถูกหยุด [1] + หยุดการนอนหลับ 50$ sleep 100 & # ปล่อยให้งานอื่นรันอยู่เบื้องหลัง [2] 11138$ งาน # ตรวจสอบสถานะงานปัจจุบัน งานหนึ่งกำลังทำงานอยู่ และอีกงานหนึ่ง หยุดแล้ว [ 1]+ หยุดการนอนหลับ 50[2]- กำลังนอนหลับ 100 &
$ bg %1[2]+ นอน 50 &
อย่างไรก็ตาม หากต้องการใช้การควบคุมงานภายใต้บรรทัดคำสั่ง เชลล์ปัจจุบัน ไดรเวอร์เทอร์มินัลเคอร์เนล ฯลฯ จำเป็นต้องรองรับการควบคุมงาน
"การเขียนโปรแกรมขั้นสูงในสภาพแวดล้อม UNIX"