ಒಂದೇ ಆಜ್ಞೆಯೊಂದಿಗೆ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕೊಲ್ಲು

ಟರ್ಮಿನಲ್ ಮೂಲಕ ನಾವು ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕೊಲ್ಲಬೇಕಾಗಿದೆ. ಪ್ರಕ್ರಿಯೆಯ ಪೂರ್ಣ ಹೆಸರು ನಮಗೆ ತಿಳಿದಿದ್ದರೆ (ಉದಾಹರಣೆಗೆ: ಕೇಟ್) ನಮಗೆ ಯಾವುದೇ ಸಮಸ್ಯೆಗಳಿಲ್ಲ, ಸರಳ:

killall kate

ಇದು ನಮಗೆ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುತ್ತದೆ ... ಆದರೆ ಪ್ರಕ್ರಿಯೆಯ ನಿಖರವಾದ ಹೆಸರು ನಮಗೆ ತಿಳಿದಿಲ್ಲದಿದ್ದರೆ ಏನಾಗುತ್ತದೆ?

ಆ ಸಂದರ್ಭಗಳಲ್ಲಿ, ನಾವು ಎಲ್ಲಾ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡಬೇಕಾಗುತ್ತದೆ ps ಆಕ್ಸ್ ಕೆಳಗಿನ ಸ್ಕ್ರೀನ್‌ಶಾಟ್‌ನಲ್ಲಿ ತೋರಿಸಿರುವಂತೆ:

ನಂತರ ಪ್ರಕ್ರಿಯೆಯ ಪಿಐಡಿಗಾಗಿ ನೋಡಿ, ಈ ಸಂದರ್ಭದಲ್ಲಿ ನಾವು ಪಿಐಡಿಯನ್ನು ಹುಡುಕುತ್ತೇವೆ ಕೇಟ್:

ಆ ಮೂಲಕ ಇದನ್ನು ಮಾಡಿ:

kill 3808

ಮತ್ತು ವಾಯ್ಲಾ, ಅಲ್ಲಿ ನಾವು ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕೊಲ್ಲುತ್ತೇವೆ.

ಸರಿ ... ಒಂದೇ ಸಾಲಿನಲ್ಲಿ ನಾವು ಪ್ರಕ್ರಿಯೆಯನ್ನು ಹುಡುಕಬಹುದು (ಅದರ ಪೂರ್ಣ ಹೆಸರನ್ನು ತಿಳಿಯದೆ), ಅದರ ಪಿಐಡಿಯನ್ನು ಕಂಡುಹಿಡಿಯಬಹುದು ಮತ್ತು ಅದನ್ನು ಕೊಲ್ಲಬಹುದು:
ps ax | grep kat | grep -v grep | awk '{print $2}' | xargs kill

ನೀವು ನೋಡುವಂತೆ:

1. ನಾವು ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡುತ್ತೇವೆ (ps ಆಕ್ಸ್)
2. ಇದರ ಪೂರ್ಣ ಅಥವಾ ನಿಖರವಾದ ಹೆಸರು ನಮಗೆ ತಿಳಿದಿಲ್ಲ ಕೇಟ್ (ಹೇ, ಅದು ಕೇಟ್-ಎಡಿಟರ್ ಅಥವಾ ಅಂತಹದ್ದಾಗಿರಬಹುದು) ಆದ್ದರಿಂದ ನಾವು ಮಾತ್ರ ಫಿಲ್ಟರ್ ಮಾಡುತ್ತೇವೆ ಕ್ಯಾಟ್ (ಗ್ರೆಪ್ ಕ್ಯಾಟ್)
3. ಆದರೆ ನಾವು ಈ ಫಿಲ್ಟರ್ ಅನ್ನು ಮಾತ್ರ ಬಳಸಿದರೆ ನಾವು ಕ್ಯಾಟ್‌ಗೆ ಸಂಬಂಧಿಸಿದ ಎರಡು ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಪಡೆಯುತ್ತೇವೆ, ಅದು ಕೇಟ್ ಪ್ರಕ್ರಿಯೆ, ಮತ್ತು ಇನ್ನೊಂದು ನಾವು ಫಿಲ್ಟರಿಂಗ್‌ಗಾಗಿ ಸಕ್ರಿಯಗೊಳಿಸುವ ಪ್ರಕ್ರಿಯೆ, ನಾನು ನಿಮಗೆ ಸ್ಕ್ರೀನ್‌ಶಾಟ್ ಅನ್ನು ಬಿಡುತ್ತೇನೆ ಇದರಿಂದ ನೀವು ತಿಳುವಳಿಕೆಯನ್ನು ಮುಗಿಸಬಹುದು: (2 ಸಾಲುಗಳಿವೆ, ಅಂದರೆ 2 ಪ್ರಕ್ರಿಯೆಗಳಿವೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ)

4. ಮೊದಲು ವಿವರಿಸಿದ್ದನ್ನು ತಪ್ಪಿಸಲು, ನಾವು ಮತ್ತೊಂದು ಫಿಲ್ಟರ್ ಅನ್ನು ತಯಾರಿಸುತ್ತೇವೆ (grep -v grep). ನಾವು ಇದಕ್ಕೆ ವಿರುದ್ಧವಾಗಿ ಏನು ಮಾಡುತ್ತೇವೆ ... ನಾವು grep ಬಳಸಿ ಫಿಲ್ಟರ್ ಮಾಡಿದರೆ, ಅದು ಫಿಲ್ಟರ್‌ನೊಂದಿಗೆ ಮಾತ್ರ ಹೊಂದಾಣಿಕೆಗಳನ್ನು ತೋರಿಸುತ್ತದೆ grep -v ಪಂದ್ಯಗಳನ್ನು ತೋರಿಸಲು ನಾವು ನಿಮಗೆ ಸೂಚಿಸುತ್ತೇವೆ, ಆದರೆ ಹೊಂದಿಕೆಯಾಗದದನ್ನು ತೋರಿಸಲು. ಫಲಿತಾಂಶವು ಇಲ್ಲಿಯವರೆಗೆ ಹೇಗೆ ಇರುತ್ತದೆ ಎಂಬುದರ ಸ್ಕ್ರೀನ್‌ಶಾಟ್ ಅನ್ನು ನಾನು ನಿಮಗೆ ತೋರಿಸುತ್ತೇನೆ: (ಈಗ ಕೇಟ್‌ನ ಪ್ರಕ್ರಿಯೆ ಮಾತ್ರ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ)

5. ಸರಿ, ನಾವು ಈಗಾಗಲೇ ಪ್ರತ್ಯೇಕವಾಗಿ ಕೊಲ್ಲಲು ಬಯಸುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಹೊಂದಿದ್ದೇವೆ, ಈಗ ನಾವು ಅದರ ಪಿಐಡಿಯನ್ನು ಮಾತ್ರ ಹೊರತೆಗೆಯಬೇಕಾಗಿದೆ, ಅದು 2 ನೇ ಸಂಖ್ಯೆ, ಅಂದರೆ, 4062. ಮತ್ತು ಪಿಐಡಿ 2 ನೇ ಕಾಲಂನಲ್ಲಿದೆ (1 ನೇ ಕಾಲಮ್ ಯುಐಡಿ 1000 ಹೊಂದಿರುವ ಬಳಕೆದಾರರನ್ನು ಒಳಗೊಂಡಿದೆ), ಆದ್ದರಿಂದ awk ಅನ್ನು ಬಳಸುವುದರಿಂದ ಅದು 2 ನೇ ಕಾಲಂನಲ್ಲಿ ಅದು ಕಂಡುಕೊಳ್ಳುವದನ್ನು ಆ ಸಾಲಿನಿಂದ ಮಾತ್ರ ತೋರಿಸುತ್ತದೆ ಎಂದು ನಾವು ಹೇಳಬಹುದು (awk '{print $ 2}'). ಇದು ನಮಗೆ ಪ್ರಕ್ರಿಯೆಯ ಸಂಖ್ಯೆಯನ್ನು ಮಾತ್ರ ತೋರಿಸುತ್ತದೆ, ಅಂದರೆ, ಟರ್ಮಿನಲ್‌ನಲ್ಲಿ ಪಿಐಡಿ ಮಾತ್ರ ಕಾಣಿಸುತ್ತದೆ.
6. ಆದರೆ ನಾವು ಪಿಐಡಿಯನ್ನು ತೋರಿಸಲು ಬಯಸುವುದಿಲ್ಲ, ಆ ಪಿಐಡಿಯೊಂದಿಗೆ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕೊಲ್ಲುವುದು ನಮಗೆ ಬೇಕಾಗಿರುವುದು ... ಆದ್ದರಿಂದ ನಾವು ಅದನ್ನು ಮಾಡುತ್ತೇವೆ, ನಾವು ಇಲ್ಲಿಯವರೆಗೆ ಇದ್ದದ್ದನ್ನು ಆಜ್ಞೆಯ ಕಡೆಗೆ ರವಾನಿಸುತ್ತೇವೆ ಕೊಲ್ಲಲು ಮತ್ತು ಸಿದ್ಧವಾಗಿದೆ (xargs ಕೊಲ್ಲುತ್ತಾರೆ)
7. ಆ ಕ್ಸಾರ್ಗ್‌ಗಳ ಅರ್ಥವೇನು? ... ಸರಳ, ಈ ಸಂದರ್ಭದಲ್ಲಿ ನಾವು ಪೈಪ್‌ಗಳಿಂದ ಮಾತ್ರ ಕೊಲ್ಲಲು ಪಿಐಡಿ ರವಾನಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ( | ), ಇದು ಕೇವಲ ಸಾಕಾಗುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ xargs (ಅದು ಮೌಲ್ಯಗಳು ಅಥವಾ ಡೇಟಾವನ್ನು ರವಾನಿಸಲು ಮತ್ತು ನಂತರ ಅವುಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಅಥವಾ ಕೊಲ್ಲಲು ಅನುಮತಿಸುತ್ತದೆ) ಎಂಬುದು ಕೆಲಸವನ್ನು ಮುಗಿಸಲು ನಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಮತ್ತು ಇಲ್ಲಿ ಅದು ಕೊನೆಗೊಳ್ಳುತ್ತದೆ

ಹೌದು ... ಇದು ಸ್ವಲ್ಪ ಸಂಕೀರ್ಣವಾಗಿದೆ ಎಂದು ನನಗೆ ತಿಳಿದಿದೆ, ಅದಕ್ಕಾಗಿಯೇ ನಾನು ಅದನ್ನು ಸಾಧ್ಯವಾದಷ್ಟು ವಿವರಿಸಲು ಪ್ರಯತ್ನಿಸಿದೆ.

Sé que posiblemente a pocos les hará falta este comando, pero el objetivo de este artículo es el mismo que el de DesdeLinux, enseñarles algo nuevo cada día, intentando siempre que pierdan el miedo o temor a Linux… y, personalmente me encantaría también que aprendan a usar sin temor la terminal 😉

ಹೇಗಾದರೂ ... ನೀವು ಅದನ್ನು ಆಸಕ್ತಿದಾಯಕವೆಂದು ಭಾವಿಸಿದ್ದೀರಿ, ಹೇಗೆ ಬಳಸಬೇಕೆಂದು ನಾನು ಕಲಿಯುತ್ತಿದ್ದೇನೆ ಅವಾಕ್ ಇದು ನಿಜವಾಗಿಯೂ ಅದ್ಭುತವಾಗಿದೆ.

ಸಂಬಂಧಿಸಿದಂತೆ