ਬੈਕਗਰਾਊਂਡ ਵਿੱਚ ਪੈਰਲਲ ਵਿੱਚ ਰਨ ਵਾਸਤੇ ਸਬਸੇਲਜ਼ ਨੂੰ ਕਿਵੇਂ ਸਿਖਾਇਆ ਜਾਵੇ
ਇੱਕ ਸ਼ੈੱਲ ਲੀਨਕਸ ਸਿਸਟਮ ਉੱਤੇ ਕਮਾਂਡਾਂ ਦੇਣ ਲਈ ਇੱਕ ਬੇਸਿਕ ਇੰਟਰਫੇਸ ਹੈ. ਇਸਦੇ ਨਾਲ, ਤੁਸੀਂ ਸਿੱਧੇ ਸਿੱਧੇ ਇੱਕ ਕਮਾਂਡ ਦਰਜ ਕਰ ਸਕਦੇ ਹੋ ਜਾਂ ਇੱਕ ਫਾਇਲ (ਸਕਰਿਪਟ) ਨਿਸ਼ਚਿਤ ਕਰ ਸਕਦੇ ਹੋ ਜਿਸ ਵਿੱਚ ਚਲਾਉਣ ਲਈ ਕਮਾਡਾਂ ਦਾ ਕ੍ਰਮ ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ. ਸ਼ੈੱਲ ਇੱਕ ਲੜੀ ਵਿੱਚ ਆਯੋਜਿਤ ਕੀਤੇ ਗਏ ਹਨ, ਅਤੇ ਕੋਈ ਵੀ ਸ਼ੈਲ ਇੱਕ ਨਵਾਂ ਸ਼ੈੱਲ ਬਣਾ ਸਕਦਾ ਹੈ. ਨਵੇਂ ਸ਼ੈੱਲ ਨੂੰ ਇਕ ਬਾਲ ਪ੍ਰਕਿਰਿਆ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ-ਇਕ ਸਬ-ਹਾੱਲ-ਪੇਰੈਂਟ ਸ਼ੈਲ ਦਾ ਜੋ ਇਸ ਨੂੰ ਬਣਾਉਂਦਾ ਹੈ.
ਡਿਫਾਲਟ ਤੌਰ ਤੇ ਇੱਕ ਸਬਸ਼ੀਲ ਇਸਦੇ ਮਾਤਾ ਜਾਂ ਪਿਤਾ ਉੱਤੇ ਇਸ ਆਧਾਰ ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿ ਜੇਕਰ ਮੂਲ ਪ੍ਰਕਿਰਿਆ ਸਮਾਪਤ ਹੋ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਸਬਹੈਲ ਵੀ ਬੰਦ ਹੋ ਜਾਂਦਾ ਹੈ. ਕੋਈ ਵੀ ਆਉਟਪੁਟ ਸਬਸਹੇਲ ਤੋਂ ਪੇਰੈਂਟ ਸ਼ੈਲ ਤਕ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ.
ਸਬਸੇਲ ਕਿਵੇਂ ਤਿਆਰ ਕਰੀਏ
Bash ਸ਼ੈੱਲ ਸਕਰਿਪਟ ਵਿੱਚ, ਤੁਸੀਂ ਬਰੈਕਟਸਿਸ ਸੰਕੇਤ ਵਰਤ ਕੇ ਇੱਕ ਸਬਸ਼ੀਲ ਬਣਾਉ:
#! / bin / bash echo "ਸਬਸੈਲ ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ" (ਗਿਣਤੀ = 1 ਜਦੋਂ ਕਿ [$ count -le 99] ਕੀ "$ count" ਸਲੀਪ 1 ((ਗਿਣਤੀ ++) ਕੀਤਾ ਹੈ) ਈਕੋ "ਮੁਕੰਮਲ"ਉਦਾਹਰਨ ਵਿੱਚ, ਜਦੋਂ ਕਿ ਲੂਪ ਪੈਰੇਸਟੀਸਿਸ ਵਿੱਚ ਘਿਰਿਆ ਹੋਇਆ ਹੈ, ਜਿਸ ਨਾਲ ਇਸਨੂੰ ਸ਼ੈਲ ਦੇ ਸਬਸੇਲ ਵਿੱਚ ਐਕਜ਼ੀਕਿਯੂਟ ਹੋਣ ਦਾ ਕਾਰਨ ਬਣਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਸਕਰਿਪਟ ਫਾਇਲ ਨੂੰ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ.
ਬੈਕਗ੍ਰਾਉਂਡ ਵਿਚ ਸਬਸੇਲ ਚਲਾਉਣਾ
ਜਦ ਤੱਕ ਕਿ ਤੁਸੀਂ ਸਬਹੈੱਲ ਨੂੰ ਬੈਕਗਰਾਊਂਡ ਵਿੱਚ ਚਲਾਉਣ ਲਈ ਨਹੀਂ ਕਹਿੰਦੇ ਹੋ, ਤਾਂ ਮੁੱਢਲਾ ਸ਼ੈੱਲ ਬਾਕੀ ਦੇ ਸਕਰਿਪਟ ਦੇ ਨਾਲ ਜਾਰੀ ਰਹਿਣ ਤੋਂ ਪਹਿਲਾਂ ਸਬਸੈਲ ਨੂੰ ਖਤਮ ਕਰਨ ਦੀ ਉਡੀਕ ਕਰਦਾ ਹੈ. ਪਰ, ਜੇ ਤੁਸੀਂ ਅਨੁਸਾਰੀ subshells ਨੂੰ ਚਲਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤੁਸੀਂ ਉਹਨਾਂ ਨੂੰ ਬੈਕਗਰਾਊਂਡ ਵਿੱਚ ਚਲਾਉਂਦੇ ਹੋ, ਜੋ ਐਂਪਸਸੈਂਡ ਅੱਖਰ ਨਾਲ ਪੂਰਾ ਹੁੰਦਾ ਹੈ ਜੋ ਸਬਸ਼ੇਲ ਐਕਸਪਰੈਸ਼ਨ ਤੋਂ ਬਾਅਦ ਹੁੰਦਾ ਹੈ, ਜਿਵੇਂ ਇੱਥੇ ਦਿਖਾਇਆ ਗਿਆ ਹੈ:
#! / bin / bash echo "subshell ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ" (ਗਿਣਤੀ = 1 ਜਦੋਂ ਕਿ [$ count -le 99] ਕੀ "$ count" ਸਲੀਪ 1 ((ਗਿਣਤੀ ++) ਕੀਤਾ) ਅਤੇ "ਮੁਕੰਮਲ"ਪੈਰਲਲ ਵਿਚ ਮਲਟੀਪਲ ਸਬਹੈਲਲਜ਼ ਚਲਾਉਣਾ
ਜੇ ਤੁਸੀਂ ਬੈਕਗਰਾਊਂਡ ਪ੍ਰਕਿਰਿਆਵਾਂ ਦੇ ਤੌਰ ਤੇ ਬਹੁਤ ਸਾਰੇ ਸਬਹੈਲਲਾਂ ਬਣਾਉਂਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਕਾਰਜਾਂ ਨੂੰ ਸਮਾਂਤਰ ਰਚ ਸਕਦੇ ਹੋ. ਆਮ ਤੌਰ ਤੇ, ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਹਰੇਕ ਪ੍ਰਕਿਰਿਆ ਅਤੇ ਉਪ-ਪ੍ਰੋਸੈਸ ਲਈ ਵੱਖੋ-ਵੱਖ ਪਰੋਸੈਸਰ ਜਾਂ ਕੋਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਇਹ ਸੋਚਦੇ ਹੋਏ ਕਿ ਬਹੁਤ ਸਾਰੇ ਪ੍ਰੋਸੈਸਰ ਜਾਂ ਕੋਰ ਹਨ ਜਿਵੇਂ ਕਾਰਜ ਹਨ. ਨਹੀਂ ਤਾਂ, ਕੰਮ ਉਸੇ ਪ੍ਰਕਿਰਿਆ ਜਾਂ ਕੋਰਾਂ ਲਈ ਨਿਰਧਾਰਤ ਕੀਤੇ ਜਾਂਦੇ ਹਨ. ਇਸ ਹਾਲਤ ਵਿੱਚ, ਕੰਮ ਪੂਰਾ ਹੋਣ ਤੱਕ ਪ੍ਰੋਸੈਸਰ ਜਾਂ ਕੋਰ ਨਿਰੰਤਰ ਕੰਮ ਦੇ ਵਿਚਕਾਰ ਸਵਿਚ ਕਰਦਾ ਹੈ. ਅਗਲੀ ਉਦਾਹਰਣ ਵਿੱਚ ਦੋ ਉਪ-ਪ੍ਰੋਸੈਸ ਹਨ ਪਹਿਲੀ ਵਾਰ 1 ਤੋਂ 99 ਤੱਕ ਦਾ ਅੰਕੜਾ ਹੈ, ਅਤੇ ਦੂਜਾ 1000 ਤੋਂ 1099 ਤੱਕ ਹੈ.
#! / bin / bash echo "subshell ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ" (ਗਿਣਤੀ = 1 ਜਦੋਂ [$ count -le 99] ਨੂੰ "$ count" ਸਲੀਪ 1 ((ਗਿਣਤੀ ++) ਕੀਤਾ) ਅਤੇ (ਗਿਣਤੀ = 1000 ਜਦੋਂ [$ count -le] 1099] ਕਰਦੇ ਹੋ "$ count" ਸਲੀਪ 1 ((ਗਿਣਤੀ ++) ਕੀਤਾ) ਅਤੇ "ਮੁਕੰਮਲ"ਬਾਕੀ ਦੇ ਸਕ੍ਰਿਪਟ ਨਾਲ ਅੱਗੇ ਵਧਣ ਤੋਂ ਪਹਿਲਾਂ ਉਪਪ੍ਰੋਸੈਸੀਆਂ ਨੂੰ ਖਤਮ ਕਰਨ ਲਈ ਮਾਪੇ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਦੱਸਣ ਲਈ ਉਡੀਕ ਬਿਆਨ ਦੀ ਵਰਤੋਂ ਕਰੋ :
#! / bin / bash echo "subshell ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ" (ਗਿਣਤੀ = 1 ਜਦੋਂ [$ count -le 99] ਨੂੰ "$ count" ਸਲੀਪ 1 ((ਗਿਣਤੀ ++) ਕੀਤਾ) ਅਤੇ (ਗਿਣਤੀ = 1000 ਜਦੋਂ [$ count -le] 1099] ਕਰਦੇ ਹੋ "$ count" sleep 1 ((count ++) ਕੀਤਾ) ਅਤੇ "ਉਡੀਕ" ਦੀ ਉਡੀਕ ਕਰੋSubshells ਲਈ ਉਪਯੋਗ
Subshells ਲਾਭਦਾਇਕ ਹਨ ਜਦੋਂ ਕਮਾਂਡਾਂ ਨੂੰ ਕਿਸੇ ਖਾਸ ਵਾਤਾਵਰਣ ਜਾਂ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਚਲਾਉਣ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ. ਜੇ ਹਰੇਕ ਕਮਾਂਡ ਇੱਕ ਵੱਖਰੇ ਸਬਹੈੱਲ ਵਿੱਚ ਚੱਲਦੀ ਹੈ, ਤਾਂ ਕੋਈ ਖ਼ਤਰਾ ਨਹੀਂ ਹੁੰਦਾ ਹੈ ਕਿ ਵੇਰੀਏਬਲ ਨੂੰ ਮਿਲਾਇਆ ਜਾਵੇਗਾ. ਮੁਕੰਮਲ ਹੋਣ ਤੇ, ਸੈਟਿੰਗਾਂ ਅਤੇ ਮੌਜੂਦਾ ਡਾਇਰੈਕਟਰੀ ਨੂੰ ਮੁੜ ਬਹਾਲ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਨਹੀਂ ਹੁੰਦੀ, ਕਿਉਂਕਿ ਮੂਲ ਪ੍ਰਕਿਰਿਆ ਦਾ ਵਾਤਾਵਰਣ ਕਿਸੇ ਵੀ ਉਪ ਪ੍ਰੌਕਸੇਸਾਂ ਦੁਆਰਾ ਪ੍ਰਭਾਵਿਤ ਨਹੀਂ ਹੁੰਦਾ ਹੈ.
ਸਬਸੇਲਜ਼ ਨੂੰ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ ਤਾਂ ਕਿ ਉਹ ਵੱਖ-ਵੱਖ ਪੈਰਾਮੀਟਰਾਂ ਨਾਲ ਕਈ ਵਾਰ ਚਲਾਏ ਜਾ ਸਕਣ.