การฆ่ากระบวนการบางครั้งเป็นวิธีเดียวที่จะกำจัดมันได้ แม้จะมีชื่อที่รุนแรง แต่การ "ฆ่า" กระบวนการก็หมายถึง "บังคับให้เลิก" วิธีดำเนินการจากบรรทัดคำสั่ง Linux หรือ macOS มีดังนี้
กระบวนการคืออะไร?
การรันโปรแกรมต่างๆเช่นเว็บเบราว์เซอร์กระบวนการพื้นหลังที่เกี่ยวข้องกับสภาพแวดล้อมเดสก์ท็อปและบริการระบบ Linux เป็นกระบวนการทั้งหมด
คุณสามารถรวมกระบวนการออกเป็นสองกลุ่ม:
- กระบวนการเบื้องหน้า คือสิ่งที่ผู้ใช้เริ่มต้นหรือเปิดตัว อาจอยู่ในหน้าต่างเทอร์มินัลหรืออาจเป็นแอปพลิเคชันกราฟิก
- กระบวนการเบื้องหลัง เป็นกระบวนการทั้งหมดที่เริ่มต้นโดยอัตโนมัติและไม่มีการโต้ตอบใด ๆ กับผู้ใช้ พวกเขาไม่คาดหวังการป้อนข้อมูลจากผู้ใช้และไม่ได้นำเสนอผลลัพธ์หรือผลลัพธ์ให้กับพวกเขา กระบวนการเบื้องหลังคือสิ่งต่างๆเช่นบริการและภูต
หากกระบวนการเบื้องหน้าคือส่วนหน้าของทีมงานโรงละครและนักแสดงกระบวนการเบื้องหลังคือทีม“ เบื้องหลัง” หลังเวที
เมื่อกระบวนการทำงานผิดปกติหรือทำงานผิดพลาดอาจทำให้เสียเวลา CPU มากเกินไปกินแรมของคุณหรือเข้าสู่วงจรการคำนวณที่แน่นและไม่ตอบสนอง แอปพลิเคชันกราฟิกสามารถปฏิเสธที่จะตอบสนองต่อการคลิกเมาส์ แอปพลิเคชัน Terminal อาจไม่ส่งคืนคุณไปยังพรอมต์คำสั่ง
คำตอบที่มีมนุษยธรรม
กระบวนการ“ ฆ่า” หมายถึง“ การบังคับให้กระบวนการเลิก” สิ่งนี้อาจจำเป็นหากกระบวนการปฏิเสธที่จะตอบสนอง
Linux ให้ไฟล์
ฆ่า
,
pkill
และ
killall
คำสั่งเพื่อให้คุณทำสิ่งนั้นได้ คำสั่งเหล่านี้สามารถใช้ได้กับกระบวนการประเภทกราฟิกหรือบรรทัดคำสั่งพื้นหน้าหรือพื้นหลัง
คำสั่งฆ่า
ใช้
ฆ่า
คุณต้องทราบรหัสกระบวนการ (PID) ของกระบวนการที่คุณต้องการยุติ
ปล
คำสั่งสามารถใช้เพื่อค้นหา PID ของกระบวนการ
เพื่อที่จะมี
ปล
ค้นหากระบวนการทั้งหมดโดยใช้ไฟล์
-คือ
(กระบวนการทั้งหมด) ตัวเลือก วางท่อเอาท์พุทผ่าน
น้อยกว่า
ขอแนะนำให้ใช้มันค่อนข้างน้อย ประเภท
ปล
, ช่องว่าง,
-คือ
, ช่องว่าง,
|
(อักขระไปป์) เว้นวรรคแล้วพิมพ์
น้อยกว่า
. กด Enter เพื่อดำเนินการคำสั่ง
ps -e | น้อยกว่า
นี่จะให้รายชื่อกระบวนการที่ดูเหมือนกับภาพหน้าจอด้านล่าง คุณสามารถค้นหาได้ใน
น้อยกว่า
ใช้
/
และคุณสามารถค้นหาย้อนหลังได้โดยใช้ปุ่ม
?
สำคัญ.
ในการดำเนินการตามขั้นตอนที่คุณสนใจให้กำหนดผลลัพธ์
ปล
ผ่าน
จับ
และระบุชื่อ - หรือบางส่วนของชื่อ - ของกระบวนการ
ps -e | นักกีฬา grep
เมื่อคุณพบ PID ของกระบวนการที่คุณต้องการยุติแล้วให้ส่งไปที่ไฟล์
ฆ่า
คำสั่งเป็นพารามิเตอร์ เพื่อยุติไฟล์
ชัตเตอร์
กระบวนการที่ระบุโดยคำสั่งก่อนหน้าให้ใช้คำสั่งนี้:
ฆ่า 2099
ฆ่า
คำสั่งเป็นนักฆ่าที่เงียบ - มันจะไม่ให้ข้อเสนอแนะใด ๆ แก่คุณหากมันสำเร็จ
คำสั่ง pkill
pkill
คำสั่งอนุญาตให้คุณฆ่ากระบวนการหรือกระบวนการตามชื่อ คุณไม่จำเป็นต้องระบุกระบวนการโดย PID ใช้
pkill
คุณระบุข้อความค้นหาว่า
pkill
ใช้เพื่อตรวจสอบกับรายการของกระบวนการที่กำลังทำงานอยู่ กระบวนการจับคู่สิ้นสุดลง ดังนั้นคุณต้องคิดบวกคุณมีข้อความค้นหาที่สะกดถูกต้อง
ในฐานะตาข่ายนิรภัยคุณสามารถใช้ไฟล์
pgrep
คำสั่ง
ก่อน
คุณใช้ไฟล์
pkill
คำสั่ง
pgrep
คำสั่งยังยอมรับคำค้นหา จะแสดงรายการ PID ของแต่ละกระบวนการที่ตรงกับคำค้นหา ปลอดภัยเพราะ
pgrep
จะไม่ส่งสัญญาณการฆ่าไปยังกระบวนการและหากคุณพิมพ์ข้อความค้นหาผิดคุณจะไม่ฆ่ากระบวนการอื่นโดยไม่ได้ตั้งใจ คุณสามารถตรวจสอบว่าคุณได้คิดคำค้นหาอย่างถูกต้องแล้วก่อนที่จะส่งต่อไป
pkill
. ทั้งสอง
pkill
และ
pgrep
ปฏิบัติต่อข้อความค้นหาในลักษณะเดียวกัน การรักษาของพวกเขาคล้ายกันมากจน
แบ่งปันหน้าคนเดียวกัน
.
สมมติว่ามีกระบวนการที่มี“ subq” อยู่ในชื่อของมัน เราจะใช้ไฟล์
ps -u dave | grep
คำสั่งเพื่อแอบดูหลังม่าน คุณจะเห็นได้ว่า“ subq” จะจับคู่กระบวนการนั้นและกระบวนการนั้นเพียงอย่างเดียว เพียงเท่านี้คุณก็จะเห็นชื่อเต็มของกระบวนการ
ps -u dave | grep subq
สมมติว่าเป็นผู้ใช้ของเรา
ไม่มี
ทำอย่างนั้น; ทั้งหมดที่พวกเขารู้ก็คือชื่อกระบวนการมีสตริงย่อย“ subq” พวกเขาใช้
pgrep
เพื่อตรวจสอบว่ามีเพียงคำเดียวที่ตรงกับข้อความค้นหา จากนั้นใช้คำค้นหานั้นกับ
pkill
.
pgrep subq
pkill subq
คุณสามารถใช้ได้
pkill
เพื่อฆ่าหลายกระบวนการพร้อมกัน ที่นี่ผู้ใช้เรียกใช้
pgrep
เพื่อตรวจสอบจำนวนกระบวนการที่ Chrome เปิดใช้งาน พวกเขาใช้
pkill
เพื่อฆ่าพวกเขาทั้งหมด จากนั้นตรวจสอบด้วย
pgrep
ที่พวกเขาถูกลบออกทั้งหมด
pgrep โครเมี่ยม
pkill chrome
pgrep โครเมี่ยม
หากหลายกระบวนการที่มีชื่อเดียวกันกำลังทำงานอยู่ แต่คุณไม่ต้องการฆ่ามันทั้งหมดคุณสามารถใช้
pgrep
กับ
-f
(บรรทัดคำสั่ง) เพื่อระบุกระบวนการที่เป็น ตัวอย่างง่ายๆคือสอง
ปิง
กระบวนการ คุณต้องการฆ่าหนึ่งในนั้น แต่ไม่ฆ่าอีกคน คุณสามารถใช้บรรทัดคำสั่งเพื่อแยกความแตกต่างระหว่างบรรทัดคำสั่ง สังเกตการใช้เครื่องหมายคำพูดเพื่อตัดพารามิเตอร์บรรทัดคำสั่ง
pgrep -f "ping 192.168.4.22"
pkill -f "ping 192.168.4.22"
คำสั่ง killall
คำเตือน
: ในระบบปฏิบัติการ Solaris และ OpenIndiana ไฟล์
killall
คำสั่งจะ
ฆ่ากระบวนการทั้งหมดที่เป็นของคุณ
. ถ้าเป็นรูทหรือถ้าคุณได้ออก
sudo killall
คุณจะรีบูตเครื่องคอมพิวเตอร์ของคุณ! ในระหว่างการวิจัยบทความนี้พฤติกรรมนี้ได้รับการยืนยันด้วย OpenIndiana Hipster เวอร์ชันล่าสุด 2018.10
killall
คำสั่ง
ดำเนินการในลักษณะเดียวกัน
ไปที่
pkill
คำสั่ง แต่มีความแตกต่างเฉพาะ แทนที่จะส่งคำค้นหาไปยังคำสั่งคุณต้องระบุชื่อกระบวนการที่แน่นอน
คุณไม่สามารถระบุการจับคู่บางส่วนกับชื่อกระบวนการได้ คุณต้องระบุชื่อกระบวนการทั้งหมดดังที่แสดง:
killall บานประตูหน้าต่าง
ชัตเตอร์ killall
- ย
ตัวเลือก (อายุน้อยกว่า) ช่วยให้คุณสามารถฆ่ากระบวนการที่ทำงานอยู่ได้
น้อยกว่า
กว่าระยะเวลาที่กำหนด ระยะเวลาจะเป็นตัวเลขตามด้วยหนึ่งในหน่วยต่อไปนี้:
- s (วินาที)
- เมตร (นาที)
- h (ชั่วโมง)
- d (วัน)
- w (สัปดาห์)
- M (เดือนหมายเหตุตัวพิมพ์ใหญ่ "M")
- y (ปี)
เพื่อฆ่ากระบวนการที่เรียกว่า
แม่
ที่เพิ่งเปิดตัวและปล่อยให้อินสแตนซ์เก่า ๆ ของ
แม่
คุณสามารถใช้พารามิเตอร์ต่อไปนี้กับไฟล์
killall
หากคุณตอบสนองภายในสองนาที:
ทำให้ฉันน้อยลงหรือฉัน
-
ตัวเลือก (เก่ากว่า) ช่วยให้คุณสามารถฆ่ากระบวนการที่ทำงานมานานกว่าช่วงเวลาที่กำหนด คำสั่งนี้จะฆ่าทั้งหมด
ssh
การเชื่อมต่อที่ทำงานมานานกว่าหนึ่งวัน:
killall -o 1d sshd
อย่าเกินไปให้มีความสุข
คำสั่งเหล่านี้จะช่วยให้คุณระบุและยุติกระบวนการที่ผิดพลาดด้วยความถูกต้องและปลอดภัยอย่างถูกต้อง
ระมัดระวังเสมอ ขั้นแรกตรวจสอบให้แน่ใจว่ากระบวนการที่คุณกำลังจะฆ่านั้นเป็นกระบวนการที่คุณต้องการจริงๆ ประการที่สองตรวจสอบอีกครั้ง - ระมัดระวังและให้แน่ใจว่ากระบวนการที่กำหนดเป้าหมายเป็นกระบวนการที่คุณต้องการยุติ ดำเนินการยุติกระบวนการเมื่อคุณพอใจแล้ว
