ការត្រួតពិនិត្យ Python proxy៖ ហេតុអ្វី Future.cancel() ទុក thread ឱ្យដំណើរការ

worker មួយរកឃើញ proxy ដែលអាចប្រើបាន។ អ្នកត្រឡប់អាសយដ្ឋានរបស់វា ហៅ cancel លើ future ផ្សេងទៀត ហើយរំពឹងថាសកម្មភាពបណ្តាញនឹងឈប់។ វាអាចនឹងមិនឈប់។

Future អាចត្រូវបានបោះបង់មុនពេល callable របស់វាចាប់ផ្តើម។ នៅពេល thread កំពុងអនុវត្តសំណើរួចហើយ ការបោះបង់ Future របស់វាមិនរំខានដល់ប្រតិបត្តិការ socket នោះទេ។ worker ត្រូវការប្រតិបត្តិការបណ្តាញដែលមានកំណត់ និងផ្លូវសម្អាតផ្ទាល់ខ្លួន។

អាយុកាលរបស់ executor ក៏សំខាន់ដែរ។ ការចាកចេញពីបរិបទ ThreadPoolExecutor រង់ចាំការងាររបស់វាបញ្ចប់។ ការរកឃើញលទ្ធផលរហ័សមួយ បន្ទាប់មករង់ចាំ worker យឺតជាច្រើន អាចធ្វើឱ្យការពន្យារពេលសរុបរបស់អ្នកហៅមើលទៅមិនដូច latency ដែលអ្នកឈ្នះបានរាយការណ៍ទាល់តែសោះ។

កំណត់ការប្រណាំងមុនពេលចាប់ផ្តើម

• កំណត់ចំនួនការត្រួតពិនិត្យក្នុងពេលដំណាលគ្នា ជំនួសឱ្យការដាក់បញ្ជីសាធារណៈគ្មានដែនកំណត់។ បញ្ជី proxy ឥតគិតថ្លៃ ផ្តល់បេក្ខជនសម្រាប់ការបញ្ចូលរបស់អ្នកត្រួតពិនិត្យ ដោយរក្សា protocol របស់ចំណុចបញ្ចប់នីមួយៗសម្រាប់ worker។
• ផ្តល់ឱ្យសំណើនីមួយៗនូវគោលនយោបាយតភ្ជាប់ និងអានដ៏សមស្រប។
• ផ្តល់ឱ្យអ្នកហៅនូវថវិកាសម្រេចចិត្តសរុប។
• កំណត់ថាតើអ្នកណាបញ្ចេញ ឬបិទលទ្ធផលពី worker ដែលរស់រានលើសពីការសម្រេចចិត្ត។

ការរង់ចាំតិចជាងមុនសម្រាប់ Future មិនដូចគ្នានឹងការធ្វើឱ្យសំណើមូលដ្ឋានរបស់វាខ្លីជាងមុនទេ។ ដូចគ្នាដែរ ការបោះបង់លទ្ធផលមិនដោះលែងធនធានបណ្តាញទាំងអស់ភ្លាមៗទេ។

លទ្ធផលជោគជ័យដំបូងក៏គ្រាន់តែជាការត្រួតពិនិត្យជោគជ័យដំបូងប៉ុណ្ណោះ។ វាអាចអាស្រ័យលើការកំណត់ពេល ការតភ្ជាប់ដែលបានឃ្លាំងសម្ងាត់ និងគោលដៅត្រួតពិនិត្យជាក់លាក់។ វាមិនបង្ហាញថាចំណុចបញ្ចប់គឺលឿនបំផុតជាសាកល ឬថាកិច្ចការពិតនឹងជោគជ័យទេ។

ជាញឹកញាប់ អាងតូចដែលរក្សាទុកជាមួយការសង្កេតថ្មីៗគឺសាមញ្ញជាងការប្រណាំងជាមួយបញ្ជីទាំងមូលមុនពេលទាញយកនីមួយៗ។ ប្រើលទ្ធផលនៃប្រតិបត្តិការពិតដើម្បីធ្វើបច្ចុប្បន្នភាពកំណត់ត្រា ជាមួយ គោលនយោបាយស្តារឡើងវិញដែលគ្រប់គ្រងសម្រាប់ការបរាជ័យ។ ការត្រួតពិនិត្យជាមុនគួរតែរកចំណូលគ្រប់ថ្លៃរបស់វា ជាជាងបង្កើនកិច្ចការនីមួយៗទ្វេដងតាមទម្លាប់។