ಹಿನ್ನೆಲೆಯಲ್ಲಿ ಸಮಾನಾಂತರವಾಗಿ ಚಾಲನೆ ಮಾಡಲು ಸಬ್ಹೆಲ್ಗಳನ್ನು ಹೇಗೆ ಸೂಚಿಸಬೇಕು
ಒಂದು ಶೆಲ್ ಎನ್ನುವುದು ಲಿನಕ್ಸ್ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಆದೇಶಗಳನ್ನು ನಮೂದಿಸುವ ಒಂದು ಮೂಲಭೂತ ಸಂಪರ್ಕಸಾಧನವಾಗಿದೆ. ಇದರೊಂದಿಗೆ, ನೀವು ಕಮಾಂಡ್ ಅನ್ನು ನೇರವಾಗಿ ನಮೂದಿಸಬಹುದು ಅಥವಾ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಆದೇಶಗಳ ಅನುಕ್ರಮವನ್ನು ಹೊಂದಿರುವ ಫೈಲ್ (ಸ್ಕ್ರಿಪ್ಟ್) ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು. ಶೆಲ್ಗಳನ್ನು ಕ್ರಮಾನುಗತದಲ್ಲಿ ಆಯೋಜಿಸಲಾಗಿದೆ, ಮತ್ತು ಯಾವುದೇ ಶೆಲ್ ಹೊಸ ಶೆಲ್ ಅನ್ನು ರಚಿಸಬಹುದು. ಹೊಸ ಶೆಲ್ ಅನ್ನು ಮಗುವಿನ ಪ್ರಕ್ರಿಯೆ ಎಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ-ಇದು ಪೋಷಕ ಶೆಲ್ ಅನ್ನು ರಚಿಸುವ ಶೆಲ್ಹೆಲ್.
ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಒಂದು ಸಬ್ಹೆಲ್ಲ್ ಪೋಷಕ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕೊನೆಗೊಳಿಸಿದರೆ, ಸಬ್ಹೆಲ್ಲ್ ಸಹ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಎಂಬ ಅರ್ಥದಲ್ಲಿ ಅದರ ಪೋಷಕರ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದೆ. ಯಾವುದೇ ಔಟ್ಪುಟ್ ಅನ್ನು ಶೆಲ್ಲಿಲ್ ನಿಂದ ಪೋಷಕ ಶೆಲ್ಗೆ ವರ್ಗಾಯಿಸಲಾಗುತ್ತದೆ.
ಒಂದು ಸಬ್ಹೆಲ್ ಅನ್ನು ಹೇಗೆ ರಚಿಸುವುದು
ಬ್ಯಾಷ್ ಶೆಲ್ ಲಿಪಿಯಲ್ಲಿ, ನೀವು ಆವರಣದ ಸಂಕೇತವನ್ನು ಬಳಸಿಕೊಂಡು ಒಂದು ಸಬ್ಹೆಲ್ ಅನ್ನು ರಚಿಸಿ:
#! / bin / bash echo "subshell ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು" (= ಎಣಿಕೆ -ಎಲ್ 99] ಪ್ರತಿಧ್ವನಿ "$ count" ನಿದ್ರೆ 1 ((ಎಣಿಕೆ ++)) ಮಾಡುವಾಗ ಎಕೋ "ಮುಗಿದಿದೆ"ಉದಾಹರಣೆಗೆ, ಆ ಸಮಯದಲ್ಲಿ ಲೂಪ್ ಆವರಣದಲ್ಲಿ ಸುತ್ತುವರೆಯಲ್ಪಟ್ಟಿರುತ್ತದೆ, ಇದು ಸ್ಕ್ರಿಪ್ಟ್ ಫೈಲ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಶೆಲ್ನ ಒಂದು ಶೆಲ್ಲಿನಲ್ಲಿ ಕಾರ್ಯರೂಪಕ್ಕೆ ತರಲು ಕಾರಣವಾಗುತ್ತದೆ.
ಹಿನ್ನೆಲೆಯಲ್ಲಿ ಸಬ್ಹೆಲ್ ರನ್ನಿಂಗ್
ಹಿನ್ನೆಲೆಯಲ್ಲಿ ಸಬ್ಹೆಲ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕೆಂದು ನೀವು ನಿರ್ದಿಷ್ಟಪಡಿಸದಿದ್ದರೆ, ಉಳಿದ ಸ್ಕ್ರಿಪ್ಟ್ನೊಂದಿಗೆ ಮುಂದುವರೆಯುವುದಕ್ಕೆ ಮುಂಚೆ ಉಪಶೀರ್ಷಿಕೆ ಪೂರ್ಣಗೊಳ್ಳಲು ಪೋಷಕ ಶೆಲ್ ಕಾಯುತ್ತದೆ. ಹೇಗಾದರೂ, ನೀವು ಸಮಾನಾಂತರವಾಗಿ subshells ಚಲಾಯಿಸಲು ಬಯಸಿದರೆ, ನೀವು ಹಿನ್ನೆಲೆಯಲ್ಲಿ ಅವುಗಳನ್ನು ಚಲಾಯಿಸಲು, ಇದು ಇಲ್ಲಿ ತೋರಿಸಿರುವಂತೆ, ಉಪಶೀರ್ಷಿಕೆ ಅಭಿವ್ಯಕ್ತಿ ಕೆಳಗಿನ ampersand ಪಾತ್ರದೊಂದಿಗೆ ಸಾಧಿಸಲಾಗುತ್ತದೆ:
#! / bin / bash echo "subshell ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು" (ಎಣಿಕೆ = 1 [$ count -le 99] ಪ್ರತಿಧ್ವನಿ "$ count" ನಿದ್ರೆ 1 ((ಎಣಿಕೆ ++)) ಮಾಡಲಾಗುತ್ತದೆ ಮತ್ತು ಪ್ರತಿಧ್ವನಿ "ಮುಗಿದಿದೆ"ಸಮಾನಾಂತರದಲ್ಲಿ ಬಹು ಸಬ್ಹೆಲ್ಗಳನ್ನು ರನ್ನಿಂಗ್
ನೀವು ಅನೇಕ ಸಬ್ಹೀಲ್ಗಳನ್ನು ಹಿನ್ನೆಲೆ ಪ್ರಕ್ರಿಯೆಗಳಂತೆ ರಚಿಸಿದರೆ, ನೀವು ಸಮಾನಾಂತರವಾಗಿ ಕಾರ್ಯಗಳನ್ನು ಚಲಾಯಿಸಬಹುದು. ವಿಶಿಷ್ಟವಾಗಿ, ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಯು ಪ್ರತಿ ಪ್ರಕ್ರಿಯೆಗೆ ಮತ್ತು ಉಪಪ್ರಕ್ರಿಯೆಗೆ ವಿಭಿನ್ನ ಪ್ರೊಸೆಸರ್ಗಳು ಅಥವಾ ಕೋರ್ಗಳನ್ನು ಬಳಸುತ್ತದೆ, ಪ್ರಕ್ರಿಯೆಗಳಿರುವಂತೆ ಅನೇಕ ಪ್ರೊಸೆಸರ್ಗಳು ಅಥವಾ ಕೋರ್ಗಳನ್ನು ಹೊಂದಿರುವುದನ್ನು ಊಹಿಸಲಾಗಿದೆ. ಇಲ್ಲವಾದರೆ, ಕಾರ್ಯಗಳು ಅದೇ ಪ್ರೊಸೆಸರ್ಗಳು ಅಥವಾ ಕೋರ್ಗಳಿಗೆ ನಿಯೋಜಿಸಲ್ಪಡುತ್ತವೆ. ಆ ಸಂದರ್ಭದಲ್ಲಿ, ಕಾರ್ಯಗಳು ಪೂರ್ಣಗೊಳ್ಳುವವರೆಗೆ ಪ್ರೊಸೆಸರ್ ಅಥವಾ ಕೋರ್ ನಿರಂತರವಾಗಿ ನಿಯೋಜಿಸಲಾದ ಕಾರ್ಯಗಳ ನಡುವೆ ಬದಲಾಗುತ್ತದೆ. ಮುಂದಿನ ಉದಾಹರಣೆ ಎರಡು ಉಪಪ್ರೊಸೆಸಸ್ಗಳನ್ನು ಹೊಂದಿದೆ. ಮೊದಲನೆಯದು 1 ರಿಂದ 99 ರವರೆಗೆ ಮತ್ತು 1000 ರಿಂದ 1099 ರವರೆಗಿನ ಎರಡನೆಯದು.
#! / bin / bash echo "subshell ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು" (ಎಣಿಕೆ = 1 [$ count -le 99] ಪ್ರತಿಧ್ವನಿ "$ ಎಣಿಕೆ" ನಿದ್ರೆ 1 ((ಎಣಿಕೆ ++)) ಮಾಡಲಾಗುತ್ತದೆ) ಮತ್ತು (ಎಣಿಕೆ = 1000 ಆದರೆ [$ count -le 1099] ಪ್ರತಿಧ್ವನಿ "$ ಎಣಿಕೆ" ನಿದ್ರೆ 1 ((ಎಣಿಕೆ ++)) ಮಾಡಲಾಗುತ್ತದೆ ಮತ್ತು ಪ್ರತಿಧ್ವನಿ "ಮುಗಿದಿದೆ"ಸ್ಕ್ರಿಪ್ಟ್ನ ಉಳಿದ ಭಾಗಗಳೊಂದಿಗೆ ಮುಂದುವರಿಯುವುದಕ್ಕೆ ಮುಂಚಿತವಾಗಿ ಉಪಪ್ರಬಂಧಗಳು ಮುಕ್ತಾಯಗೊಳ್ಳಲು ಪೋಷಕ ಪ್ರಕ್ರಿಯೆಯನ್ನು ತಿಳಿಸಲು ಕಾಯುವ ಹೇಳಿಕೆಯನ್ನು ಬಳಸಿ:
#! / bin / bash echo "subshell ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು" (ಎಣಿಕೆ = 1 [$ count -le 99] ಪ್ರತಿಧ್ವನಿ "$ ಎಣಿಕೆ" ನಿದ್ರೆ 1 ((ಎಣಿಕೆ ++)) ಮಾಡಲಾಗುತ್ತದೆ) ಮತ್ತು (ಎಣಿಕೆ = 1000 ಆದರೆ [$ count -le 1099] ಪ್ರತಿಧ್ವನಿ "$ ಎಣಿಕೆ" ನಿದ್ರೆ 1 ((ಎಣಿಕೆ ++)) ಮಾಡಲಾಗುತ್ತದೆ ಮತ್ತು ಪ್ರತಿಧ್ವನಿ "ಮುಕ್ತಾಯ"ಸಬ್ಹೆಲ್ಸ್ಗಾಗಿ ಉಪಯೋಗಗಳು
ಆಜ್ಞೆಗಳನ್ನು ಒಂದು ನಿರ್ದಿಷ್ಟ ಪರಿಸರದಲ್ಲಿ ಅಥವಾ ಕೋಶದಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಅಗತ್ಯವಿದ್ದಾಗ ಚಂದಾದಾರಿಕೆಗಳು ಉಪಯುಕ್ತವಾಗಿವೆ. ಪ್ರತಿ ಕಮಾಂಡ್ ಅನ್ನು ಬೇರೆ ಬೇರೆ ಆಧಾರದಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಿದರೆ, ವೇರಿಯಬಲ್ ಸೆಟ್ಟಿಂಗ್ಗಳನ್ನು ಮಿಶ್ರಣ ಮಾಡುವ ಅಪಾಯವಿರುವುದಿಲ್ಲ. ಪೂರ್ಣಗೊಂಡ ನಂತರ, ಸೆಟ್ಟಿಂಗ್ಗಳು ಮತ್ತು ಪ್ರಸಕ್ತ ಡೈರೆಕ್ಟರಿಯು ಪುನಃಸ್ಥಾಪಿಸಲು ಅಗತ್ಯವಿಲ್ಲ, ಏಕೆಂದರೆ ಪೋಷಕ ಪ್ರಕ್ರಿಯೆಯ ಪರಿಸರವು ಅದರ ಯಾವುದೇ ಉಪಪ್ರೊಸೆಸಸ್ಗಳಿಂದ ಪ್ರಭಾವಿತವಾಗಿರುವುದಿಲ್ಲ.
ಸಬ್ಹೆಲ್ಗಳನ್ನು ಫಂಕ್ಷನ್ ಡೆಫಿನಿಷನ್ಸ್ಗಳಲ್ಲಿ ಬಳಸಬಹುದಾಗಿರುತ್ತದೆ, ಆದ್ದರಿಂದ ಅವುಗಳನ್ನು ವಿವಿಧ ನಿಯತಾಂಕಗಳೊಂದಿಗೆ ಅನೇಕ ಬಾರಿ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು.