ಪ್ರಕ್ರಿಯೆಗಳು ಯಾವುವು ಮತ್ತು ನಾವು ಅವುಗಳನ್ನು ಉಬುಂಟುನಲ್ಲಿ ಹೇಗೆ ನಿರ್ವಹಿಸಬಹುದು

ಇಂದು ಉಬುಂಟು (ಮತ್ತು ಹೆಚ್ಚಿನ ಗ್ನು / ಲಿನಕ್ಸ್ ಡಿಸ್ಟ್ರೋಗಳು) a ಸಂಕೀರ್ಣ ಬಳಕೆದಾರ ಇಂಟರ್ಫೇಸ್, ಇದು ಬಳಕೆದಾರರಿಗೆ ಸಿಸ್ಟಮ್ ಅನ್ನು ಅದರ ಬಗ್ಗೆ ಏನೂ ತಿಳಿಯದೆ ಬಳಸಲು ಅನುಮತಿಸುತ್ತದೆ ಮತ್ತು ಅದು ಉತ್ತಮವಾಗಿದೆ. ಇದು ಬಳಕೆದಾರರಿಗೆ ಸುಧಾರಿತ ಜ್ಞಾನವನ್ನು ಹೊಂದಿಲ್ಲ ಎಂಬ ಪ್ರಮೇಯದಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಮತ್ತು ಅದಕ್ಕಾಗಿಯೇ ಸಾಮಾನ್ಯವಾಗಿ ಉಬುಂಟು ಮತ್ತು ಗ್ನು / ಲಿನಕ್ಸ್ ಬಳಕೆಯು ಹೆಚ್ಚು ಅರ್ಥಗರ್ಭಿತವಾಗಿದೆ.

ಈಗ, ನಾವು ಏನನ್ನು ಬಳಸುತ್ತಿದ್ದೇವೆ ಎಂಬುದನ್ನು ತಿಳಿದುಕೊಳ್ಳುವುದು ಎಂದಿಗೂ ನೋಯಿಸುವುದಿಲ್ಲ. ಇದಲ್ಲದೆ, ನೀವು GNU/Linux ಅನ್ನು ಬಳಸಿದರೆ ಅದು ಭಾಗಶಃ ನಿಮ್ಮ ಭಿನ್ನಾಭಿಪ್ರಾಯ, ನಿಮ್ಮ ಕುತೂಹಲ ಮತ್ತು ಕಲಿಯುವ ನಿಮ್ಮ ಬಯಕೆಯಿಂದಾಗಿ ಎಂದು ನಮಗೆ ತಿಳಿದಿದೆ. ಆದ್ದರಿಂದ ಒಳಗೆ Ubunlog ನಾವು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ತಾಂತ್ರಿಕ ಲೇಖನವನ್ನು ಬರೆಯಲು ಮತ್ತು ನಿಮಗೆ ತೋರಿಸಲು ಬಯಸುತ್ತೇವೆ ಪ್ರಕ್ರಿಯೆಗಳು ಯಾವುವು ಮತ್ತು ಅವು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಉಬುಂಟುನಲ್ಲಿ. ಚಾಲನೆಯಲ್ಲಿರುವ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡಲು, ನಿರ್ದಿಷ್ಟ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕಂಡುಹಿಡಿಯಲು ಮತ್ತು ಅವುಗಳನ್ನು ಕೊಲ್ಲಲು ನಾವು ನಿಮಗೆ ಕಲಿಸುತ್ತೇವೆ. ನಾವು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ.

ನಮಗೆಲ್ಲರಿಗೂ ತಿಳಿದಿರುವಂತೆ, ಉಬುಂಟು (ಗ್ನು / ಲಿನಕ್ಸ್) ಬಹುಕಾರ್ಯಕ ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಯಾಗಿದೆ. ಇದರರ್ಥ ಹಲವಾರು ಪ್ರಕ್ರಿಯೆಗಳನ್ನು (ಕಾರ್ಯಗಳನ್ನು) ಏಕಕಾಲದಲ್ಲಿ, ಅವುಗಳ ನಡುವೆ ಸಮಸ್ಯೆಗಳಿಲ್ಲದೆ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಾಮರ್ಥ್ಯ ಹೊಂದಿದೆ.

ಆದರೆ… ಒಂದು ಪ್ರಕ್ರಿಯೆ ಎಂದರೇನು?

ಪ್ರಕ್ರಿಯೆಯು ಪ್ರೋಗ್ರಾಂನ ಉದಾಹರಣೆಗಿಂತ ಹೆಚ್ಚೇನೂ ಅಲ್ಲ. ಅಥವಾ ಇನ್ನೊಂದು ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ಪ್ರೋಗ್ರಾಂ ಚಾಲನೆಯಲ್ಲಿರುವ ಪ್ರಕ್ರಿಯೆಗಳ ಸರಣಿಗಿಂತ ಹೆಚ್ಚೇನೂ ಅಲ್ಲ. ಆದ್ದರಿಂದ ಆಡುಮಾತಿನಲ್ಲಿ, ಪ್ರಕ್ರಿಯೆಯನ್ನು ಚಾಲನೆಯಲ್ಲಿರುವ ಪ್ರೋಗ್ರಾಂ ಎಂದು ತಿಳಿಯಬಹುದು.

ನಿಮ್ಮಲ್ಲಿ ಕೆಲವರು ಈಗಾಗಲೇ ತಿಳಿದಿರುವಂತೆ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಎರಡು ರೀತಿಯಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು; ಸೈನ್ ಇನ್ ಮುನ್ನೆಲೆ (ಮುಂಭಾಗದಲ್ಲಿ) ಅಥವಾ ಒಳಗೆ ಹಿನ್ನೆಲೆ (ಹಿನ್ನೆಲೆಯಲ್ಲಿ).

ಇದಲ್ಲದೆ, ಅತ್ಯಂತ ಕುತೂಹಲಕ್ಕಾಗಿ, ಒಂದು ಪ್ರಕ್ರಿಯೆಯು ಸಹ ಹೊಂದಿದೆ ಸ್ಥಿತಿ, ಏಕೆಂದರೆ ಅದು ಮಾತ್ರ ಸಾಧ್ಯವಿಲ್ಲ ಚಾಲನೆಯಲ್ಲಿದೆ. ಉದಾಹರಣೆಗೆ ಒಂದು ಪ್ರಕ್ರಿಯೆ A ಮತ್ತೊಂದು ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪ್ರಾರಂಭಿಸಿ B, ದಿ A ಪ್ರಕ್ರಿಯೆ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ ತಂದೆ ಮತ್ತು ಬಿ ಪ್ರಕ್ರಿಯೆಯಾಗಿ ಮಗ (ಮಗು). ಹೆಚ್ಚಾಗಿ, ಇದು ಸಂಭವಿಸಿದಾಗ, A ರಾಜ್ಯದಲ್ಲಿ ಉಳಿಯಿರಿ ಅಮಾನತುಗೊಳಿಸಲಾಗಿದೆ.

ನಾವು ಅದನ್ನು ಉದಾಹರಣೆಯೊಂದಿಗೆ ನೋಡಬಹುದು:

Si ನಾವು ಟರ್ಮಿನಲ್ ಅನ್ನು ತೆರೆಯುತ್ತೇವೆ ನಮ್ಮ ಉಬುಂಟು, ಟರ್ಮಿನಲ್ ಮತ್ತೊಂದು ಪ್ರೋಗ್ರಾಂ ಆಗಿರುವುದರಿಂದ ನಾವು ಈಗಾಗಲೇ ಹೊಸ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತಿದ್ದೇವೆ. ಹೀಗಾದರೆ ಟರ್ಮಿನಲ್ನಿಂದ ನಾವು ಮತ್ತೊಂದು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ, ಅದನ್ನು ಅಮಾನತುಗೊಳಿಸಲಾಗಿದೆ ಎಂದು ನಾವು ನೋಡುತ್ತೇವೆ. ಅಂದರೆ, ಒಮ್ಮೆ ಟರ್ಮಿನಲ್ ತೆರೆದರೆ, ನಾವು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತೇವೆ:

gedit f_test

ಎಂಬ ಹೊಸ ಫೈಲ್ ತೆರೆಯಲು f_test (ಗೆಡಿಟ್ ಪಠ್ಯ ಸಂಪಾದಕದೊಂದಿಗೆ), ಟರ್ಮಿನಲ್ ಅನ್ನು ಅಮಾನತುಗೊಳಿಸಲಾಗಿದೆ ಮತ್ತು "ನಾವು ಅದನ್ನು ಇನ್ನು ಮುಂದೆ ಬಳಸಲಾಗುವುದಿಲ್ಲ" ಎಂದು ನಾವು ನೋಡುತ್ತೇವೆ. ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪ್ರಾರಂಭಿಸಿದ ನಂತರ ಅದೇ ಟರ್ಮಿನಲ್ ಅನ್ನು ಬಳಸುವುದನ್ನು ಮುಂದುವರಿಸಲು ನಾವು ಬಯಸಿದರೆ, ಅದನ್ನು ಪ್ರಾರಂಭಿಸಿ ಹಿನ್ನೆಲೆ (ಹಿನ್ನೆಲೆ), ಅಂದರೆ, ನಾವು ಕಾರ್ಯಗತಗೊಳಿಸಿದರೆ ಸಾಕು:

gedit f_test &

"&" ಚಿಹ್ನೆಯು ಈ ಪ್ರಕ್ರಿಯೆಯನ್ನು ನಡೆಸಲು ನಾವು ಬಯಸುತ್ತೇವೆ ಎಂದು ಸೂಚಿಸುತ್ತದೆ ಹಿನ್ನೆಲೆ. ಈ ರೀತಿಯಾಗಿ, ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪ್ರಾರಂಭಿಸಿದ ನಂತರ, ನಾವು ಟರ್ಮಿನಲ್ ಅನ್ನು ಬಳಸುವುದನ್ನು ಮುಂದುವರಿಸಬಹುದು, ಏಕೆಂದರೆ ಅದನ್ನು ಅಮಾನತುಗೊಳಿಸಲಾಗುವುದಿಲ್ಲ ಮತ್ತು ಎರಡೂ ಪ್ರಕ್ರಿಯೆಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಚಾಲನೆಯಲ್ಲಿರುತ್ತವೆ.

ಉಬುಂಟುನಲ್ಲಿ ಯಾವ ಪ್ರಕ್ರಿಯೆಗಳು ನಡೆಯುತ್ತಿವೆ ಎಂದು ನಾನು ಹೇಗೆ ತಿಳಿಯಬಹುದು?

ಚಾಲನೆಯಲ್ಲಿರುವ ಪ್ರಕ್ರಿಯೆಗಳ ಪಟ್ಟಿಯನ್ನು ನೋಡಲು, ಟರ್ಮಿನಲ್ ತೆರೆಯಿರಿ ಮತ್ತು ರನ್ ಮಾಡಿ:

ps -aux

ಮತ್ತು ನಾವು ಈ ಕೆಳಗಿನಂತೆ output ಟ್ಪುಟ್ ಅನ್ನು ನೋಡುತ್ತೇವೆ:

ಪಟ್ಟಿಯಿಂದ ನಮಗೆ ಆಸಕ್ತಿ ಇರುವ ಏಕೈಕ ಮಾಹಿತಿ ಪಿಐಡಿ. ಪಿಐಡಿ (ಪ್ರಕ್ರಿಯೆ ಗುರುತಿಸುವಿಕೆ) ಒಂದು ಪೂರ್ಣಾಂಕವಾಗಿದ್ದು, ಅದರ ಹೆಸರೇ ಸೂಚಿಸುವಂತೆ, ಒಂದೇ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಗುರುತಿಸುವ ಜವಾಬ್ದಾರಿಯನ್ನು ಹೊಂದಿದೆ.

ಇದಲ್ಲದೆ, ಉಬುಂಟು (ಮತ್ತು ಎಲ್ಲಾ ಗ್ನು / ಲಿನಕ್ಸ್ ಡಿಸ್ಟ್ರೋಸ್) ಪಿಐಡಿಯ ಗರಿಷ್ಠ ಮೌಲ್ಯವನ್ನು ನಿರ್ಧರಿಸುವ ಫೈಲ್ ಅನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಇದು ಸ್ಪಷ್ಟವಾಗಿ ನಿರ್ಧರಿಸುತ್ತದೆ ಚಲಾಯಿಸಲು ಗರಿಷ್ಠ ಸಂಖ್ಯೆಯ ಪ್ರಕ್ರಿಯೆಗಳು. ಫೈಲ್ ಅನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ ಪಿಡ್_ಮ್ಯಾಕ್ಸ್ ಮತ್ತು ಅದು / proc / sys / kernel / ಡೈರೆಕ್ಟರಿಯಲ್ಲಿದೆ. ನೀವು ಅದರ ವಿಷಯವನ್ನು ತ್ವರಿತವಾಗಿ ನೋಡಲು ಬಯಸಿದರೆ, ಚಲಾಯಿಸಿ:

cat / proc / sys / kernel / pid_max

ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಗರಿಷ್ಠ ಸಂಖ್ಯೆಯ ಪ್ರಕ್ರಿಯೆಗಳು 32768 ಎಂಬುದನ್ನು ನೀವು ನೋಡುತ್ತೀರಿ. ಈ ಡೈರೆಕ್ಟರಿಗಳ ಮೂಲಕ ಚಲಿಸುವಾಗ ನೀವು ಎಚ್ಚರಿಕೆಯಿಂದ ನಡೆಯುವುದು ಬಹಳ ಮುಖ್ಯ, ಏಕೆಂದರೆ ಕೆಟ್ಟ ಬದಲಾವಣೆಯು ಮಾರಕವಾಗಬಹುದು.

ಮತ್ತೊಂದೆಡೆ, ನಾವು ಬಯಸಿದರೆ ನಿರ್ದಿಷ್ಟ ಪ್ರೋಗ್ರಾಂಗೆ ಸಂಬಂಧಿಸಿದ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಹುಡುಕಿ ಫಲಿತಾಂಶವನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲು ನಾವು ಪೈಪ್ ಮತ್ತು grep ಆಜ್ಞೆಯನ್ನು ಬಳಸಬಹುದು. ಅಂದರೆ, ಉದಾಹರಣೆಗೆ ನಾವು ಜಿಂಪ್‌ಗೆ ಸಂಬಂಧಿಸಿದ ಎಲ್ಲಾ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ನೋಡಲು ಬಯಸಿದರೆ, ನಾವು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು:

ps -aux | ಜಿಪಿ ಜಿಂಪ್

ನೀವು ನೋಡುವಂತೆ, ನನ್ನ ವಿಷಯದಲ್ಲಿ ಜಿಂಪ್‌ಗೆ ಸಂಬಂಧಿಸಿದ 3 ಪ್ರಕ್ರಿಯೆಗಳಿವೆ.

ಮತ್ತು ... ಪ್ರಕ್ರಿಯೆಯನ್ನು ನಾನು ಹೇಗೆ ಕೊಲ್ಲುವುದು?

ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕೊಲ್ಲುವುದು ಎಂದರೆ ಅದನ್ನು ಕೊನೆಗೊಳಿಸುವುದು, ಪ್ರಕ್ರಿಯೆಯು ಕೊನೆಗೊಳ್ಳಲು ಅನುಗುಣವಾದ ಸಂಕೇತವನ್ನು ಕಳುಹಿಸುವುದು. ಹಾಗೆ ಮಾಡುವುದು ಆಜ್ಞೆಯನ್ನು ಬಳಸುವಷ್ಟು ಸುಲಭ ಕೊಲ್ಲಲು. ನಾವು ಕೊಲ್ಲಲು ಬಯಸುವ ಪ್ರಕ್ರಿಯೆಯ ಪಿಐಡಿಯನ್ನು ನಾವು ತಿಳಿದುಕೊಳ್ಳಬೇಕು. ಮೇಲಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, 5649 ಅನ್ನು ಅದರ ಪಿಐಡಿಯಾಗಿ ಹೊಂದಿರುವ ಜಿಂಪ್ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕೊಲ್ಲಲು ನಾನು ಬಯಸುತ್ತೇನೆ ಎಂದು ಹೇಳೋಣ. ಸರಿ, ಓಡಿ:

ಕೊಲ್ಲು 5649

ಈಗ ನಾನು ಒಂದೇ ಸಮಯದಲ್ಲಿ ಹೇಗೆ ಕೊಲ್ಲುವುದು ಪ್ರೋಗ್ರಾಂಗೆ ಸಂಬಂಧಿಸಿದ ಎಲ್ಲಾ ಪ್ರಕ್ರಿಯೆಗಳು? ತುಂಬಾ ಸುಲಭ. ನನ್ನ ಸಂದರ್ಭದಲ್ಲಿ ನಾನು ಎಲ್ಲಾ ಜಿಂಪ್ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಕೊಲ್ಲಲು ಬಯಸಿದರೆ, ನಾನು ಆಜ್ಞೆಯನ್ನು ಬಳಸಬಹುದು pkill. ಕೆಳಗಿನ ರೀತಿಯಲ್ಲಿ:

ಪಿಕಿಲ್ ಜಿಂಪ್

ಇದು ಕೊಲ್ಲುತ್ತದೆ ಎಲ್ಲಾ ಜಿಂಪ್ ಪ್ರಕ್ರಿಯೆಗಳು, ಅಂದರೆ, ಪಿಐಡಿಗಳು 5649, 5719 ಮತ್ತು 5782 ರೊಂದಿಗಿನ ಪ್ರಕ್ರಿಯೆಗಳು. ಸುಲಭ ಸರಿ? ಒಂದು ಪ್ರೋಗ್ರಾಂ ಹೆಪ್ಪುಗಟ್ಟುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಹೇಗೆ ಕೊನೆಗೊಳಿಸಬೇಕು ಎಂದು ನಿಮಗೆ ತಿಳಿದಿಲ್ಲದಿದ್ದರೆ, ಈಗ ನಿಮಗೆ ಸಂಭವನೀಯ ಪರಿಹಾರವಿದೆ

ಉಬುಂಟು ಮತ್ತು ಲಿನಕ್ಸ್ ಸಾಮಾನ್ಯವಾಗಿ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಸ್ವಲ್ಪ ಚೆನ್ನಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಈ ಚಿಕ್ಕ ಮಾರ್ಗದರ್ಶಿ ನಿಮಗೆ ಸಹಾಯ ಮಾಡಿದೆ ಎಂದು ನಾವು ಭಾವಿಸುತ್ತೇವೆ. ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಹೇಗೆ ಕೆಲಸ ಮಾಡುವುದು ಮತ್ತು ನಿರ್ವಹಿಸುವುದು ಎಂದು ತಿಳಿದುಕೊಳ್ಳುವುದು ಲಿನಕ್ಸ್‌ನಲ್ಲಿ ಮೂಲಭೂತವಾಗಿದೆ ಮತ್ತು ಅದೇ ಸಮಯದಲ್ಲಿ ಬಹಳ ಮುಖ್ಯವಾಗಿದೆ. ಈ ಮಾರ್ಗದರ್ಶಿ ತುಂಬಾ ಸರಳ ಮತ್ತು ಸಂಕ್ಷಿಪ್ತವಾಗಿದೆ ಎಂದು ನಮಗೆ ಇನ್ನೂ ತಿಳಿದಿದೆ, ಆದ್ದರಿಂದ ನೀವು ಕುತೂಹಲ ಹೊಂದಿದ್ದರೆ ಮತ್ತು ಈ ವಿಷಯವನ್ನು ಸ್ವಲ್ಪ ಅಧ್ಯಯನ ಮಾಡಲು ಬಯಸಿದರೆ, ನೀವು ನೋಡಬಹುದು ಜೀವನ ಚಕ್ರವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿ ಅಥವಾ ಗೆ ಲಿನಕ್ಸ್ ಶೆಡ್ಯೂಲರ್ (ಪ್ರಕ್ರಿಯೆ ಯೋಜಕ).

ಮುಂದಿನ ಸಮಯದವರೆಗೆ