બાસ સ્ક્રિપ્ટ્સનો ઉપયોગ કરીને ઉપભોક્તાઓને કેવી રીતે યોગ્ય રીતે ચલાવો તે જાણો

પૃષ્ઠભૂમિમાં સમાંતરમાં ચલાવવા માટે સબસિલેને કેવી રીતે સુચના કરવી

શેલ Linux સિસ્ટમ પરના આદેશોને દાખલ કરવા માટેનું મૂળભૂત ઇન્ટરફેસ છે. તેની સાથે, તમે સીધી આદેશ દાખલ કરી શકો છો અથવા ફાઇલ (સ્ક્રિપ્ટ) નો ઉલ્લેખ કરી શકો છો જેમાં એક્ઝિક્યુટ કરવાનાં આદેશોનો ક્રમ છે. શેલોને પદાનુક્રમમાં ગોઠવવામાં આવે છે, અને કોઈપણ શેલ નવા શેલ બનાવી શકે છે. નવા શેલને બાળ પ્રક્રિયા ગણવામાં આવે છે- એક પેટા-શેલ કે જે તેને બનાવે છે.

ડિફૉલ્ટ રૂપે, પેટા શેલ તેના પિતૃ પર આધારીત છે કે જો પિતૃ પ્રક્રિયા સમાપ્ત થાય, તો સબશેલ પણ સમાપ્ત થાય છે. કોઈપણ આઉટપુટ સબશેલમાંથી પિતૃ શેલ પર પસાર થાય છે.

સબશેલ કેવી રીતે બનાવવી તે

બાસ શેલ સ્ક્રિપ્ટમાં, તમે કૌંસને નોટેશનનો ઉપયોગ કરીને એક સબશેલ બનાવો છો:

#! / bin / bash ઇકો "subshell શરૂ કરતા પહેલા" (ગણતરી = 1 જ્યારે [$ count -le 99] "$ count" સ્લીપ 1 ((count ++) પૂર્ણ કરો) "સમાપ્ત"

ઉદાહરણ તરીકે, જ્યારે લૂપ કૌંસમાં બંધ થયેલ છે, જે તેને શેલના સબશેલમાં ચલાવવા માટેનું કારણ બને છે જેમાં સ્ક્રિપ્ટ ફાઇલ ચલાવવામાં આવે છે.

પૃષ્ઠભૂમિમાં સબહેલ ચલાવી રહ્યું છે

જ્યાં સુધી તમે સ્પષ્ટ કરશો નહીં કે પાશ્વભાગમાં સબહેલ ચલાવવાનું છે, તો પિતૃ શેલ બાકીના સ્ક્રિપ્ટ સાથે ચાલુ રાખવા પહેલાં સબશેલને સમાપ્ત કરવા માટે રાહ જુએ છે. તેમ છતાં, જો તમે સમાંતરમાં subshells ચલાવવા માંગો છો, તો તમે તેને પૃષ્ઠભૂમિમાં ચલાવો છો, જે ઉપસંહાર અભિવ્યક્તિને અનુસરીને એમ્પરસેન્ડ અક્ષરથી પરિપૂર્ણ થાય છે, જે અહીં બતાવ્યા પ્રમાણે છે:

#! / bin / bash ઇકો "subshell શરૂ કરતા પહેલા" (ગણતરી = 1 જ્યારે [$ count -le 99] "$ count" સ્લીપ 1 ((count ++) પૂર્ણ કરો) અને "સમાપ્ત"

સમાંતર માં મલ્ટીપલ Subshells ચલાવી રહ્યા છીએ

જો તમે બહુવિધ ઉપભોગને પૃષ્ઠભૂમિ પ્રક્રિયાઓ તરીકે બનાવો છો, તો તમે ક્રિયાઓ સમાંતરમાં ચલાવી શકો છો. લાક્ષણિક રીતે, ઓપરેટિંગ સિસ્ટમ દરેક પ્રોસેસ અને સબ પ્રોસેસ માટે વિવિધ પ્રોસેસરો અથવા કોરોનો ઉપયોગ કરે છે, ધારી રહ્યા છીએ કે પ્રોસેસ હોય ત્યાં ઓછામાં ઓછા ઘણા પ્રોસેસર્સ અથવા કોરો છે. નહિંતર, કાર્યોને સમાન પ્રોસેસરો અથવા કોરોને સોંપવામાં આવે છે. તે કિસ્સામાં, કાર્યો પૂર્ણ ન થાય ત્યાં સુધી પ્રોસેસર અથવા કોર સતત સોંપાયેલ કાર્યો વચ્ચે સ્વિચ કરે છે. આગળના ઉદાહરણમાં બે સબ પ્રોસેસિસ છે પ્રથમ એક 1 થી 99 ની ગણતરી અને 1000 થી 1099 સુધીનો બીજો એક.

#! / bin / bash ઇકો "subshell શરૂ કરતા પહેલા" (ગણતરી = 1 જ્યારે [$ count -le 99] "$ count" સ્લીપ 1 ((count ++) પૂર્ણ કરો) અને (ગણતરી = 1000 જ્યારે [$ count -le] 1099] "$ count" સ્લીપ 1 ((ગણતરી ++) પૂર્ણ કરો) અને "સમાપ્ત"

બાકીના સ્ક્રિપ્ટમાં આગળ વધતાં પહેલાં પેટાપ્રોસેસિસને સમાપ્ત થવાની રાહ જોવા માટે પેરેંટ પ્રોસેસને કહેવા માટે રાહ સ્ટેટમેન્ટનો ઉપયોગ કરો:

#! / bin / bash ઇકો "subshell શરૂ કરતા પહેલા" (ગણતરી = 1 જ્યારે [$ count -le 99] "$ count" સ્લીપ 1 ((count ++) પૂર્ણ કરો) અને (ગણતરી = 1000 જ્યારે [$ count -le] 1099] "$ count" સ્લીપ 1 ((ગણતરી ++) પૂર્ણ થાય છે) અને "સમાપ્ત"

Subshells માટે ઉપયોગો

ઉપભોગ ઉપયોગી છે જ્યારે આદેશો ચોક્કસ પર્યાવરણ અથવા ડિરેક્ટરીમાં ચલાવવાની જરૂર છે. જો દરેક આદેશ અલગ સબહેલમાં એક્ઝિક્યુટ થાય, તો કોઈ જોખમ નથી કે વેરિયેબલ સેટિંગ્સને મિશ્રિત કરવામાં આવશે. સમાપ્તિ પર, સુયોજનો અને વર્તમાન ડિરેક્ટરીને પુનઃસ્થાપિત કરવાની જરૂર નથી, કારણ કે પિતૃ પ્રક્રિયાના વાતાવરણમાં તેની કોઈ પણ પેટાપ્રોસેસિસ દ્વારા અસર થતી નથી.

સબસેલ્સનો ઉપયોગ કાર્ય વ્યાખ્યાઓમાં થઈ શકે છે જેથી તેઓ વિવિધ પરિમાણો સાથે ઘણી વખત અમલ કરી શકાય.