वर्कर में थ्रेडिंग
संग्रह की मदद से व्यवस्थित रहें
अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.
Worker
का इस्तेमाल करने पर, WorkManager
Worker.doWork()
को अपने-आप कॉल करता है
बैकग्राउंड थ्रेड पर. बैकग्राउंड थ्रेड, Executor
से मिलता है
WorkManager के Configuration
में बताया गया है.
डिफ़ॉल्ट रूप से, WorkManager आपके लिए Executor
सेट अप करता है. हालांकि, आपके पास इन्हें अपनी पसंद के मुताबिक बनाने का विकल्प भी है
आपकी अपनी पसंद के हिसाब से. उदाहरण के लिए, आप अपने
ऐप्लिकेशन, सिंगल-थ्रेड वाला Executor
बनाएं, ताकि बैकग्राउंड में आपका पूरा डेटा काम कर सके
क्रम से लागू करता है या पसंद के मुताबिक Executor
तय करता है. कस्टमाइज़ करने के लिए
Executor
, पक्का करें कि आपने WorkManager को मैन्युअल तरीके से शुरू किया हो.
WorkManager को मैन्युअल तरीके से कॉन्फ़िगर करते समय, अपने Executor
को इस हिसाब से कॉन्फ़िगर किया जा सकता है
अनुसरण करता है:
Kotlin
WorkManager.initialize(
context,
Configuration.Builder()
// Uses a fixed thread pool of size 8 threads.
.setExecutor(Executors.newFixedThreadPool(8))
.build())
Java
WorkManager.initialize(
context,
new Configuration.Builder()
.setExecutor(Executors.newFixedThreadPool(8))
.build());
यहां एक सामान्य Worker
का उदाहरण दिया गया है, जो किसी वेबपेज का कॉन्टेंट डाउनलोड करता है
100 बार:
Kotlin
class DownloadWorker(context: Context, params: WorkerParameters) : Worker(context, params) {
override fun doWork(): ListenableWorker.Result {
repeat(100) {
try {
downloadSynchronously("https://www.google.com")
} catch (e: IOException) {
return ListenableWorker.Result.failure()
}
}
return ListenableWorker.Result.success()
}
}
Java
public class DownloadWorker extends Worker {
public DownloadWorker(Context context, WorkerParameters params) {
super(context, params);
}
@NonNull
@Override
public Result doWork() {
for (int i = 0; i < 100; i++) {
try {
downloadSynchronously("https://www.google.com");
} catch (IOException e) {
return Result.failure();
}
}
return Result.success();
}
}
ध्यान दें कि Worker.doWork()
सिंक्रोनस कॉल—आपको बैकग्राउंड का पूरा काम Google में
एक ब्लॉकिंग फ़ैशन को रोकना और उसे उस समय तक पूरा करना जब तक उसे बाहर नहीं निकाला जाता. अगर आप किसी
doWork()
में एसिंक्रोनस एपीआई और Result
दिखाता है, तो हो सकता है कि आपका कॉलबैक ये काम न करे
ठीक से काम करते हों. अगर आपके साथ भी ऐसा होता है, तो ListenableWorker
का इस्तेमाल करें. (ExploreableWorker में थ्रेडिंग), तब ऐसा कर सकती है.
जब वर्तमान में चल रहा Worker
किसी भी कारण से बंद हो जाता है, तो वह
Worker.onStopped()
पर एक कॉल आता है. इस तरीके को बदलें या
Worker.isStopped()
को कॉल करो
कोड चेकइन करने और ज़रूरत पड़ने पर संसाधनों को खाली करने के लिए. जब Worker
जो ऊपर दिए गए उदाहरण में रुकी हुई है, वह शायद अपने
आइटम डाउनलोड कर रहा है और ऐसा करना जारी रखेगा, भले ही उसे रोक दिया गया हो. यहां की यात्रा पर हूं
ऑप्टिमाइज़ करते हैं, तो आप कुछ ऐसा कर सकते हैं:
Kotlin
class DownloadWorker(context: Context, params: WorkerParameters) : Worker(context, params) {
override fun doWork(): ListenableWorker.Result {
repeat(100) {
if (isStopped) {
break
}
try {
downloadSynchronously("https://www.google.com")
} catch (e: IOException) {
return ListenableWorker.Result.failure()
}
}
return ListenableWorker.Result.success()
}
}
Java
public class DownloadWorker extends Worker {
public DownloadWorker(Context context, WorkerParameters params) {
super(context, params);
}
@NonNull
@Override
public Result doWork() {
for (int i = 0; i < 100; ++i) {
if (isStopped()) {
break;
}
try {
downloadSynchronously("https://www.google.com");
} catch (IOException e) {
return Result.failure();
}
}
return Result.success();
}
}
Worker
को बंद करने के बाद, इससे कोई फ़र्क़ नहीं पड़ता कि आपने किस साइट से वापस आया है
Worker.doWork()
; Result
को अनदेखा कर दिया जाएगा.
इस पेज पर मौजूद कॉन्टेंट और कोड सैंपल कॉन्टेंट के लाइसेंस में बताए गए लाइसेंस के हिसाब से हैं. Java और OpenJDK, Oracle और/या इससे जुड़ी हुई कंपनियों के ट्रेडमार्क या रजिस्टर किए हुए ट्रेडमार्क हैं.
आखिरी बार 2025-07-27 (UTC) को अपडेट किया गया.
[[["समझने में आसान है","easyToUnderstand","thumb-up"],["मेरी समस्या हल हो गई","solvedMyProblem","thumb-up"],["अन्य","otherUp","thumb-up"]],[["वह जानकारी मौजूद नहीं है जो मुझे चाहिए","missingTheInformationINeed","thumb-down"],["बहुत मुश्किल है / बहुत सारे चरण हैं","tooComplicatedTooManySteps","thumb-down"],["पुराना","outOfDate","thumb-down"],["अनुवाद से जुड़ी समस्या","translationIssue","thumb-down"],["सैंपल / कोड से जुड़ी समस्या","samplesCodeIssue","thumb-down"],["अन्य","otherDown","thumb-down"]],["आखिरी बार 2025-07-27 (UTC) को अपडेट किया गया."],[],[],null,["# Threading in Worker\n\nWhen you use a [`Worker`](/reference/androidx/work/Worker), WorkManager\nautomatically calls [`Worker.doWork()`](/reference/androidx/work/Worker#doWork())\non a background thread. The background thread comes from the `Executor`\nspecified in WorkManager's [`Configuration`](/reference/androidx/work/Configuration).\nBy default, WorkManager sets up an `Executor` for you---but you can also customize\nyour own. For example, you can share an existing background Executor in your\napp, create a single-threaded `Executor` to make sure all your background work\nexecutes sequentially, or even specify a custom `Executor`. To customize the\n`Executor`, make sure you initialize WorkManager manually.\n\nWhen configuring WorkManager manually, you can specify your `Executor` as\nfollows: \n\n### Kotlin\n\n```kotlin\nWorkManager.initialize(\n context,\n Configuration.Builder()\n // Uses a fixed thread pool of size 8 threads.\n .setExecutor(Executors.newFixedThreadPool(8))\n .build())\n```\n\n### Java\n\n```java\nWorkManager.initialize(\n context,\n new Configuration.Builder()\n .setExecutor(Executors.newFixedThreadPool(8))\n .build());\n```\n\nHere is an example of a simple `Worker` that downloads the contents of a webpage\n100 times: \n\n### Kotlin\n\n```kotlin\nclass DownloadWorker(context: Context, params: WorkerParameters) : Worker(context, params) {\n\n override fun doWork(): ListenableWorker.Result {\n repeat(100) {\n try {\n downloadSynchronously(\"https://www.google.com\")\n } catch (e: IOException) {\n return ListenableWorker.Result.failure()\n }\n }\n\n return ListenableWorker.Result.success()\n }\n}\n```\n\n### Java\n\n```java\npublic class DownloadWorker extends Worker {\n\n public DownloadWorker(Context context, WorkerParameters params) {\n super(context, params);\n }\n\n @NonNull\n @Override\n public Result doWork() {\n for (int i = 0; i \u003c 100; i++) {\n try {\n downloadSynchronously(\"https://www.google.com\");\n } catch (IOException e) {\n return Result.failure();\n }\n }\n\n return Result.success();\n }\n\n}\n```\n\nNote that [`Worker.doWork()`](/reference/androidx/work/Worker#doWork()) is a\nsynchronous call---you are expected to do the entirety of your background work in\na blocking fashion and finish it by the time the method exits. If you call an\nasynchronous API in `doWork()` and return a [`Result`](/reference/androidx/work/ListenableWorker.Result), your callback may not\noperate properly. If you find yourself in this situation, consider using a [`ListenableWorker`](/reference/androidx/work/ListenableWorker) (see [Threading in ListenableWorker](/topic/libraries/architecture/workmanager/advanced/listenableworker)).\n\nWhen a currently running `Worker` is [stopped for any reason](/topic/libraries/architecture/workmanager/how-to/managing-work#cancelling), it\nreceives a call to [`Worker.onStopped()`](/reference/androidx/work/ListenableWorker#onStopped()). Override this method or\ncall [`Worker.isStopped()`](/reference/androidx/work/ListenableWorker#isStopped())\nto checkpoint your code and free up resources when necessary. When the `Worker`\nin the example above is stopped, it may be in the middle of its loop of\ndownloading items and will continue doing so even though it has been stopped. To\noptimize this behavior, you can do something like this: \n\n### Kotlin\n\n```kotlin\nclass DownloadWorker(context: Context, params: WorkerParameters) : Worker(context, params) {\n\n override fun doWork(): ListenableWorker.Result {\n repeat(100) {\n if (isStopped) {\n break\n }\n\n try {\n downloadSynchronously(\"https://www.google.com\")\n } catch (e: IOException) {\n return ListenableWorker.Result.failure()\n }\n\n }\n\n return ListenableWorker.Result.success()\n }\n}\n```\n\n### Java\n\n```java\npublic class DownloadWorker extends Worker {\n\n public DownloadWorker(Context context, WorkerParameters params) {\n super(context, params);\n }\n\n @NonNull\n @Override\n public Result doWork() {\n for (int i = 0; i \u003c 100; ++i) {\n if (isStopped()) {\n break;\n }\n\n try {\n downloadSynchronously(\"https://www.google.com\");\n } catch (IOException e) {\n return Result.failure();\n }\n }\n\n return Result.success();\n }\n}\n```\n\nOnce a `Worker` has been stopped, it doesn't matter what you return from\n`Worker.doWork()`; the `Result` will be ignored."]]