The Chromium Chronicle #1: टास्क को शेड्यूल करने के सबसे सही तरीके

Chrome टीम को Chromium Chronicle लॉन्च करते हुए गर्व हो रहा है. यह हर महीने लॉन्च होने वाली एक सीरीज़ है. इसे खास तौर पर Chromium डेवलपर के लिए बनाया गया है. इन डेवलपर को ब्राउज़र बनाना होता है.

Chromium Chronicle मुख्य तौर पर, Chrome लिखने, बनाने, और टेस्ट करने के सबसे सही तरीकों और तकनीकी जानकारी के प्रसार पर फ़ोकस करेगा. हमारी योजना में ऐसे विषय शामिल करने हैं जो Chromium डेवलपर के लिए काम के और काम के हों. उदाहरण के लिए, कोड हेल्थ, मददगार टूल, यूनिट टेस्टिंग, सुलभता वगैरह! हर लेख Chrome के इंजीनियर लिखते हैं और उनमें बदलाव भी करते हैं.

हम इस नई सीरीज़ को लेकर बहुत उत्साहित हैं और उम्मीद करते हैं कि आप भी इस सीरीज़ से खुश होंगे! क्या आप इसे एक्सप्लोर करने के लिए तैयार हैं? नीचे हमारा पहला एपिसोड देखें!

टास्क शेड्यूल करने के सबसे सही तरीके

एपिसोड 1: मॉन्ट्रिऑल, पीक्यू (अप्रैल, 2019) में गेब्रियल चैरेट की पेशकश
पिछले एपिसोड

वह Chrome कोड जिसे इन-प्रोसेस एसिंक्रोनस एक्ज़ीक्यूशन की ज़रूरत होती है, आम तौर पर टास्क को क्रम में पोस्ट करता है. क्रम, Chrome की मदद से मैनेज किए जाने वाले "वर्चुअल थ्रेड" होते हैं. इनका इस्तेमाल, खुद के थ्रेड बनाने के लिए किया जाता है. किसी ऑब्जेक्ट को कैसे पता चलता है कि किस क्रम में पोस्ट करना है?

यह न करें

पुराने मॉडल में, क्रिएटर से SeriesdTaskRunner हासिल करना है:

Foo::Foo(scoped_refptr backend_task_runner)
    : backend_task_runner_(std::move(backend_task_runner)) {}
ऐसा करें

पसंदीदा मॉडल एक स्वतंत्र SequencedTaskRunner बनाना है:

Foo::Foo()
    : backend_task_runner_(
          base::CreateSequencedTaskRunnerWithTraits({
              base::MayBlock(), base::TaskPriority::BEST_EFFORT})) {}

इसे पढ़ना और लिखना आसान होता है, क्योंकि सभी जानकारी स्थानीय होती है. साथ ही, एक-दूसरे पर निर्भर काम करने की संभावना नहीं होती.

टेस्टिंग के मामले में भी यह मॉडल बेहतर साबित होता है. मैन्युअल तरीके से टास्क रनर को इंजेक्ट करने के बजाय, टेस्ट से कंट्रोल किए गए टास्क एनवायरमेंट को इंस्टैंशिएट किया जा सकता है. इससे फ़ू के टास्क मैनेज किए जा सकते हैं:

class FooTest : public testing::Test {
 public
  (...)
 protected:
  base::test::TaskEnvironment task_environment_;
  Foo foo_;
};

Task एनवायरमेंट को पहले रखने से, यह अपने-आप पक्का हो जाता है कि फ़ूओ के पूरे समय के दौरान टास्क को मैनेज किया जा सकता है. Task एनवायरमेंट, SequencedTask Runner बनाने के लिए, बनाए जाने वाले फ़ू के अनुरोध को कैप्चर करेगा. साथ ही, यह हर FooTest के तहत, अपने टास्क मैनेज करेगा.

एसिंक्रोनस एक्ज़ीक्यूशन के नतीजे की जांच करने के लिए, RunLoop::Run()+QuitClosure() मॉडल का इस्तेमाल करें:

TEST_F(FooTest, TestAsyncWork) {
  RunLoop run_loop;
  foo_.BeginAsyncWork(run_loop.QuitClosure());
  run_loop.Run();
  EXPECT_TRUE(foo_.work_done());
}

इसके बजाय, RuntillIdle() का इस्तेमाल किया जा सकता है.अगर एसिंक्रोनस वर्कलोड में TaskEnvironment के निजी डेटा से बाहर का कोई टास्क शामिल है, तो यह अस्थिर हो सकता है. जैसे, कोई सिस्टम इवेंट, इसलिए RunUntilIdle() का इस्तेमाल सावधानी से करें.

क्या आपको और जानकारी चाहिए? थ्रेडिंग और टास्क के बारे में हमारा दस्तावेज़ पढ़ें या TaskEnvironment पर माइग्रेट करें में शामिल हों!