பைத்தானில் மல்டிபிராசசிங்கை எவ்வாறு சிறப்பாக செயல்படுத்துவது?

உலகெங்கிலும் தொழில்நுட்ப வளர்ச்சிக்கு 2019 மிகப் பெரிய ஆண்டாக அமைந்துள்ளது. கணினி உற்பத்தியாளர்கள் தங்கள் சிபியுக்கள் மற்றும் செயலிகளில் மொபைல் ஃபோன்களில் சிறந்த சில்லுகளை அறிமுகப்படுத்துவதில் இருந்து அதிக கோர்களைச் சேர்ப்பது தொடங்கி, மல்டி பிராசசிங் என்பது இனி ஒரு கனவு அல்ல. இன்று, மல்டிபிராசசிங்கை ஆதரிக்கும் மிக முக்கியமான நிரலாக்க மொழிகளில் ஒன்று . அதன் வெளியீட்டில் இணையான செயலாக்க சக்தியை அறிமுகப்படுத்தியதற்கு நன்றி, உலகெங்கிலும் உள்ள குறியீட்டாளர்கள் இப்போது ஒரே நேரத்தில் செயல்படுத்தப்பட வேண்டிய குறியீடுகளை தடையின்றி உருவாக்க முடியும், இதனால் அவற்றின் இயக்க நேரம் ஒரு குறிப்பிடத்தக்க அளவு.

இந்த கட்டுரையில் பின்வரும் சுட்டிகள் விவரிக்கப்படும்,

தொடக்கநிலைகளுக்கான தகவல் பயிற்சி பி.டி.எஃப்

• மல்டிபிராசஸிங் என்றால் என்ன?
• பைத்தானில் மல்டிபிராசசிங்கிற்கான குறியீடு
• எடுத்துக்காட்டு 1
• எடுத்துக்காட்டு 2

ஆரம்பிக்கலாம்,

பைத்தானில் மல்டிபிராசஸிங்

மல்டிபிராசஸிங் என்றால் என்ன?

எந்தவொரு சந்தர்ப்பத்திலும் ஒன்றுக்கு மேற்பட்ட செயல்பாடுகளை ஆதரிக்கும் ஒரு அமைப்பின் திறன் என மல்டிபிராசஸிங் வரையறுக்கப்படுகிறது. இதன் பொருள் என்னவென்றால், மல்டி பிராசசிங் சிஸ்டங்களில் உள்ள பயன்பாடுகள் சிறிய துண்டுகளாக பிரிக்கப்பட்டு பின்னர் ஒருவருக்கொருவர் சுயாதீனமாக இயங்குவதற்காக செயல்திறனை அதிகரிக்கும் மற்றும் ஒட்டுமொத்த ரன் நேரத்தைக் குறைக்கும். கணினியில் உள்ள செயலி ஒவ்வொரு சிறிய பகுதியையும் அதன் சொந்த ஒரு சுயாதீன நூலை ஒதுக்குகிறது, இதனால் இது ஒரு முழுமையான நிறுவனமாக செயல்பட அனுமதிக்கிறது.

மல்டிபிராசசிங்கின் தேவை

ஒரு கணினி அமைப்பை கற்பனை செய்து பாருங்கள், அதன் செயலியில் ஒரே ஒரு கோர் மட்டுமே உள்ளது. இந்த ஒற்றை மையத்திற்கு பல பணிகள் ஒதுக்கப்பட்டால், அது ஒவ்வொரு பணியையும் இடையில் உடைத்து அடுத்ததாக மாறுகிறது. இது ஒவ்வொரு பணியையும் முடிக்கத் தேவையான நேரத்தை அதிகரிக்காது, ஆனால் அமைப்பின் ஒட்டுமொத்த செயல்திறனையும் குறைக்கும்.

மறுபுறம், ஒரு மல்டிப்ரோசெசிங் கம்ப்யூட்டரில், ஒரு செயலியைக் கொண்டிருக்கலாம், இதன் விளைவாக பல செயல்பாட்டு அலகுகள் உள்ளன, அவை தனிப்பட்ட கோர்கள் என அழைக்கப்படுகின்றன, அவை ஒரே நேரத்தில் பல வேறுபட்ட பணிகளை சுயாதீனமாக இயக்கும் திறனைக் கொண்டுள்ளன. இது கணினியின் செயல்திறனை அதிகரிப்பது மட்டுமல்லாமல், நீண்ட காலமாக கணினியின் இயக்க நேரத்தை கணிசமான அளவு குறைக்கிறது.

பைத்தானில் ஒரு மல்டிபிராசசிங் சிஸ்டம் இரண்டு வகைகளாக இருக்கலாம்.

பல செயலி அமைப்பு

இந்த அமைப்பு அடிப்படையில் பல செயலிகளைக் கொண்டுள்ளது, அவை ஒவ்வொன்றும் ஒரு நேரத்தில் ஒரு பணியைச் செய்ய முடியும் மற்றும் ஒரு சுயாதீனமான கூறுகளாக செயல்படலாம்.

மல்டி கோர் செயலி அமைப்பு

இந்த அமைப்பில் ஒரே செயலியில் பல கோர்கள் உள்ளன, அதற்குள் கோர் ஒரு தனி யூனிட்டாக செயல்படுகிறது மற்றும் அதற்கு ஒதுக்கப்பட்டுள்ள பணிகளை சுயாதீனமாக செய்கிறது.

பைத்தானில் மல்டிபிராசசிங்கிற்கான குறியீடு

மல்டிப்ரோசெசிங்கின் அடிப்படைக் கருத்தாக்கத்திற்கு இப்போது நீங்கள் பழக்கமாகிவிட்டீர்கள், பைத்தானில் மல்டிபிராசசிங் எவ்வாறு அடைய முடியும் என்பதை ஆராய்வோம்.

பைத்தானில், மொழிபெயர்ப்பாளர் மிகவும் எளிமையான மற்றும் உள்ளுணர்வு API ஐக் கொண்டிருக்கிறார், இது ஒரு பணியை எடுத்து, பல கூறுகளாக உடைத்து அவற்றை சுயாதீனமாக செயலாக்குகிறது.

பைத்தானில் மல்டிப்ரோசெசிங் என்ற இந்த கருத்தை நன்கு புரிந்துகொள்ள கீழேயுள்ள நிரல் தொகுதியைப் பாருங்கள்.

எடுத்துக்காட்டு 1

# மல்டிப்ரோசெசிங் தொகுதி இறக்குமதி இறக்குமதி மல்டி பிராசசிங் டெஃப் பிரிண்ட்_குயூப் (எண்): கொடுக்கப்பட்ட எண்ணின் கனசதுரத்தை அச்சிடுவதற்கான செயல்பாடு '' 'அச்சு (' கியூப்: {} '. வடிவம் (எண் * எண் * எண்)) டெஃப் பிரிண்ட்_ஸ்குவேர் (எண்): __name__ == '__main__' என்றால், கொடுக்கப்பட்ட எண்ணின் சதுரத்தை அச்சிடுவதற்கான செயல்பாடு ('சதுரம்: {}'. வடிவம் (எண் * எண்)): # உருவாக்கும் செயல்முறைகள் p1 = multirocessing.Process (target = print_square, args = (10,)) p2 = multirocessing.Process (target = print_cube, args = (10,)) # தொடக்க செயல்முறை 1 p1.start () # தொடக்க செயல்முறை 2 p2.start () # செயல்முறை 1 முடியும் வரை காத்திருங்கள் p1 .ஜாய்ன் () # செயல்முறை 2 முடியும் வரை காத்திருங்கள் p2.join () # இரண்டு செயல்முறைகளும் அச்சிடப்பட்டவை ('முடிந்தது!')

வெளியீடு

சதுரம்: 100

கன சதுரம்: 1000

முடிந்தது!

இப்போது இதை நன்கு புரிந்துகொள்ள இந்த திட்டத்தை பகுப்பாய்வு செய்வோம்.

1. முதல் படி மல்டி பிராசசிங் தொகுதியை இறக்குமதி செய்வது. இதைச் செய்ய, பின்வரும் தொடரியல் பயன்படுத்தவும்: இறக்குமதி மல்டி பிராசசிங்.

2. இப்போது மல்டி பிராசசிங் தொகுதி இறக்குமதி செய்யப்பட்டுள்ளது, நாம் முன்னேறி ஒரு செயல்முறையை உருவாக்குவோம். இதைச் செய்வதற்காக, செயல்முறை வகுப்பின் ஒரு பொருளை உருவாக்கி பின்வரும் வாதங்களை ஒதுக்குகிறோம். இலக்கு: இந்த செயல்முறையால் செயல்படுத்தப்பட வேண்டிய செயல்பாடு மற்றும் வாதங்கள்: இலக்கு செயல்பாட்டிற்கு அனுப்பப்பட வேண்டிய வாதங்கள்.

குறிப்பு: ஒரு செயல்முறை கட்டமைப்பாளருக்கு பல இலக்குகளையும் வாதங்களையும் எடுத்துக்கொள்ளும் திறன் உள்ளது, ஆனால் மேலே உள்ள எடுத்துக்காட்டில் எங்கள் செயல்முறைக்கு கீழே காட்டப்பட்டுள்ளபடி இரண்டு இலக்குகள் மற்றும் வாதங்களை மட்டுமே ஒதுக்கியுள்ளோம்.

p1 = multirocessing.Process (இலக்கு = print_square, args = (10,))

p2 = multirocessing.Process (இலக்கு = print_cube, args = (10,))

1. இப்போது செயல்முறை உருவாக்கப்பட்டது, அதைத் தொடங்குவதற்கான தொடரியல் எழுதுவோம்.

p1.start ()

p2.start ()

செயல்முறை தொடங்கப்பட்டதும், தற்போதைய நிரலும் ஏற்கனவே இயங்கும் ஒன்றும் ஒரே நேரத்தில் இயக்கப்படுகின்றன. ஒரு குறிப்பிட்ட சூழ்நிலையில், நீங்கள் தற்போதைய நிரலை செயல்படுத்துவதை நிறுத்த வேண்டும் மற்றும் முன்பே இருக்கும் ஒன்றை செயல்படுத்துவதில் மட்டுமே கவனம் செலுத்த வேண்டும் என்றால், கீழே காட்டப்பட்டுள்ளபடி சேரல் செயல்பாட்டை நாங்கள் பயன்படுத்துகிறோம்.

p1.join ()

சேமிப்பு வகுப்பு c ++

p2.join ()

இந்த தொடரியல் உள்ளிடப்பட்டதும், நிரல் p1 செயலாக்கத்தை முடிக்க மொழிபெயர்ப்பாளர் காத்திருப்பார், பின்னர் நிரல் p2 க்குச் செல்வார்.

இந்த கருத்தை மேலும் புரிந்துகொள்ள, கீழேயுள்ள பைத்தானில் மல்டிபிராசசிங்கிற்கான மற்றொரு எடுத்துக்காட்டைப் பாருங்கள்.

எடுத்துக்காட்டு 2

# மல்டிப்ரோசெசிங் தொகுதி இறக்குமதி இறக்குமதி மல்டி பிராசசிங் இறக்குமதி os டெஃப் தொழிலாளி 1 (): # அச்சிடும் செயல்முறை ஐடி அச்சு ('செயல்படும் தொழிலாளி ஐடி 1: {}'. வடிவம் (os.getpid ())) டெஃப் தொழிலாளி 2 (): # அச்சிடும் செயல்முறை ஐடி அச்சு ('செயலாக்க இயங்கும் தொழிலாளி 2: {}'. வடிவம் (os.getpid ()) என்றால் __name__ == '__main__': # அச்சிடும் பிரதான நிரல் செயல்முறை ஐடி அச்சு ('முக்கிய செயல்முறையின் ஐடி: {}'. வடிவம் (os .getpid ())) # செயல்முறைகளை உருவாக்குதல் p1 = multirocessing.Process (target = பணியாளர் 1) p2 = multirocessing.Process (target = பணியாளர் 2) # தொடக்க செயல்முறைகள் p1.start () p2.start () # செயல்முறை ஐடிகள் அச்சிடு ('ஐடி செயல்முறை p1: {} '. வடிவம் (p1.pid)) அச்சு (' செயல்முறை ஐடி p2: {} '. வடிவம் (p2.pid)) # செயல்முறைகள் முடியும் வரை காத்திருங்கள் p1.join () p2.join () # இரண்டு செயல்முறைகளும் அச்சிடப்பட்டவை ('இரண்டு செயல்முறைகளும் செயல்படுத்தல் முடிந்தது!') # செயல்முறைகள் உயிருடன் இருக்கிறதா என்று சரிபார்க்கவும் ('செயல்முறை பி 1 உயிருடன் இருக்கிறதா: {}'. வடிவம் (p1.is_alive ())) அச்சு ('செயல்முறை p2 உயிருடன் உள்ளது: {} '. வடிவமைப்பு (p2.is_alive ()))

வெளியீடு

முக்கிய செயல்முறையின் ஐடி: 18938

செயல்முறை இயங்கும் தொழிலாளர் ஐடி 1: 18939

செயல்முறை இயங்கும் தொழிலாளி 2: 18940 ஐடி

செயல்முறை ஐடி ப 1: 18939

செயல்முறை ஐடி ப 2: 18940

இரண்டு செயல்முறைகளும் மரணதண்டனை முடித்தன!

செயல்முறை பி 1 உயிருடன் உள்ளது: தவறு

செயல்முறை பி 2 உயிருடன் உள்ளது: தவறு

செயல்முறை p1 மற்றும் p2 இரண்டும் அவற்றின் தனிப்பட்ட நினைவுகளிலிருந்து சுயாதீனமாக இயங்குகின்றன என்பதை மேலே உள்ள நிரலில் கவனியுங்கள். இருவரும் மரணதண்டனை முடித்தவுடன், நிரல் நிறுத்தப்படும்.

இது பைத்தானில் மல்டிப்ரோசெசிங் குறித்த இந்த கட்டுரையின் முடிவிற்கு நம்மைக் கொண்டுவருகிறது

பைத்தானில் அதன் பல்வேறு பயன்பாடுகளுடன் ஆழமான அறிவைப் பெற, நீங்கள் செய்யலாம் 24/7 ஆதரவு மற்றும் வாழ்நாள் அணுகலுடன் நேரடி ஆன்லைன் பயிற்சிக்கு.

எங்களுக்கு ஒரு கேள்வி கிடைத்ததா? கட்டுரையின் கருத்துகள் பிரிவில் அவற்றைக் குறிப்பிடுங்கள், நாங்கள் உங்களிடம் திரும்புவோம்.