Android
AsyncTask

C# Language Cordova firebase HTML iOS Java Language JavaScript Kotlin PHP react-native
खोज…


पैरामीटर

पैरामीटर विवरण
पैरामीटर निष्पादन पर कार्य को भेजे गए मापदंडों का प्रकार।
प्रगति पृष्ठभूमि संगणना के दौरान प्रकाशित प्रगति इकाइयों का प्रकार
परिणाम पृष्ठभूमि अभिकलन के परिणाम का प्रकार।

मूल उपयोग

एंड्रॉइड एक्टिविटीज एंड सर्विसेज में , ज्यादातर कॉलबैक मुख्य धागे पर चलाए जाते हैं। यह यूआई को अपडेट करने के लिए सरल बनाता है, लेकिन मुख्य थ्रेड पर प्रोसेसर या I / O- भारी कार्य चलाने से आपका UI आपके पॉज़ करने और गैर-जिम्मेदार होने (तब क्या होता है पर आधिकारिक प्रलेखन ) हो सकता है।

आप इन भारी कार्यों को एक पृष्ठभूमि धागे पर रखकर इसका उपाय कर सकते हैं।

ऐसा करने का एक तरीका एक AsyncTask का उपयोग कर रहा है , जो पृष्ठभूमि थ्रेड के आसान उपयोग को सुविधाजनक बनाने के लिए एक फ्रेमवर्क प्रदान करता है, और बैकग्राउंड थ्रेड ने अपना काम पूरा करने से पहले, दौरान और बाद में यूआई थ्रेड कार्य भी करता है।

AsyncTask विस्तार करते समय AsyncTask तरीकों को ओवरराइड किया जा सकता है:

  • onPreExecute() : कार्य निष्पादित होने से पहले UI थ्रेड पर लागू किया गया
  • doInBackground() : onPreExecute() निष्पादन के तुरंत बाद बैकग्राउंड थ्रेड पर लागू किया गया।
  • onProgressUpdate() : UI पर publishProgress(Progress...) टू publishProgress(Progress...) ।
  • onPostExecute() : पृष्ठभूमि गणना खत्म होने के बाद UI थ्रेड पर लागू किया गया

उदाहरण 

public class MyCustomAsyncTask extends AsyncTask<File, Void, String> {

    
    @Override
    protected void onPreExecute(){
        // This runs on the UI thread before the background thread executes.
        super.onPreExecute();
        // Do pre-thread tasks such as initializing variables. 
        Log.v("myBackgroundTask", "Starting Background Task");  
    }

    @Override
    protected String doInBackground(File... params) {
        // Disk-intensive work. This runs on a background thread.
        // Search through a file for the first line that contains "Hello", and return
        // that line.
        try (Scanner scanner = new Scanner(params[0])) {
            while (scanner.hasNextLine()) {
                final String line = scanner.nextLine();
                publishProgress(); // tell the UI thread we made progress

                if (line.contains("Hello")) {
                    return line;
                }
            }
            return null;
        }
    }

    @Override
    protected void onProgressUpdate(Void...p) {
        // Runs on the UI thread after publishProgress is invoked
        Log.v("Read another line!")
    }        

    @Override
    protected void onPostExecute(String s) {
        // This runs on the UI thread after complete execution of the doInBackground() method
        // This function receives result(String s) returned from the doInBackground() method.
        // Update UI with the found string.
        TextView view = (TextView) findViewById(R.id.found_string);
        if (s != null) {
            view.setText(s);
        } else {
            view.setText("Match not found.");
        }
    }

}

उपयोग: 

MyCustomAsyncTask asyncTask = new MyCustomAsyncTask<File, Void, String>();
// Run the task with a user supplied filename.
asyncTask.execute(userSuppliedFilename);

या केवल: 

new MyCustomAsyncTask().execute(userSuppliedFilename);

ध्यान दें

एक AsyncTask को परिभाषित करते AsyncTask हम < > कोष्ठक के बीच तीन प्रकार से गुजर सकते हैं।
<Params, Progress, Result> ( पैरामीटर अनुभाग देखें) के रूप में परिभाषित

पिछले उदाहरण में हमने टाइप किया है <File, Void, String> : 

AsyncTask<File, Void, String>
// Params has type File
// Progress has unused type
// Result has type String

जब आप अप्रयुक्त के रूप में एक प्रकार चिह्नित करना चाहते हैं तो Void का उपयोग किया जाता है।

ध्यान दें कि आप आदिम प्रकार (यानी int , float और 6 अन्य) को मापदंडों के रूप में पारित नहीं कर सकते हैं। ऐसे मामलों में, आपको उनके रैपर क्लासेस को पास करना चाहिए, जैसे Integer int बजाय, या Float बजाय float ।

AsyncTask और गतिविधि जीवन चक्र

AsyncTasks गतिविधि इंस्टेंस के जीवन चक्र का पालन नहीं करते हैं। यदि आप किसी गतिविधि के अंदर एक AsyncTask शुरू करते हैं और आप डिवाइस को घुमाते हैं, तो गतिविधि नष्ट हो जाएगी और एक नया उदाहरण बन जाएगा। लेकिन AsyncTask नहीं मरेगा। यह पूरा होने तक जीवित रहेगा।

समाधान: AsyncTaskLoader

लोडर का एक उपवर्ग AsyncTaskLoader है। यह वर्ग AsyncTask के समान कार्य करता है, लेकिन बहुत बेहतर है। यह गतिविधि कॉन्फ़िगरेशन परिवर्तनों को अधिक आसानी से संभाल सकता है, और यह जीवन चक्र और गतिविधियों के चक्र के भीतर व्यवहार करता है। अच्छी बात यह है कि AsyncTaskLoader का उपयोग किसी भी स्थिति में किया जा सकता है जो AsyncTask का उपयोग किया जा रहा है। गतिविधि / फ़्रैगमेंट को संभालने के लिए किसी भी समय डेटा को मेमोरी में लोड करना होगा, AsyncTaskLoader काम को बेहतर कर सकता है।

AsyncTask रद्द करना

YourAsyncTask task = new YourAsyncTask();
task.execute();
task.cancel();

यदि यह प्रगति में था, तो यह आपके काम को नहीं रोकता है, यह केवल रद्द किए गए ध्वज को सेट करता है, जो कि ऐसा करने से isCancelled() मान मानकर चेक किया जा सकता है isCancelled() वर्तमान में आपका कोड चल रहा है): 

class YourAsyncTask extends AsyncTask<Void, Void, Void> {
    @Override
    protected Void doInBackground(Void... params) {
        while(!isCancelled()) {
            ... doing long task stuff
            //Do something, you need, upload part of file, for example
            if (isCancelled()) {    
                return null; // Task was detected as canceled
            }
            if (yourTaskCompleted) {
                return null;
            }
        }
    }
}

ध्यान दें

यदि doInBackground(Params... params) अभी भी एक AsyncTask रद्द किया जाता है, तो onPostExecute(Result result) विधि doInBackground(Params... params) रिटर्न के बाद नहीं बुलाया जाएगा। AsyncTask इसके बजाय onCancelled(Result result) को कॉल करने के लिए संकेत देगा कि कार्य निष्पादन के दौरान रद्द कर दिया गया था।

प्रकाशन प्रगति

कभी-कभी, हमें एक AsyncTask द्वारा की गई गणना की प्रगति को अपडेट करने की आवश्यकता AsyncTask । इस प्रगति को एक स्ट्रिंग, पूर्णांक आदि द्वारा दर्शाया जा सकता है। ऐसा करने के लिए, हमें दो कार्यों का उपयोग करना होगा। सबसे पहले, हमें onProgressUpdate फ़ंक्शन सेट करना onProgressUpdate जिसका पैरामीटर प्रकार हमारे AsyncTask के दूसरे प्रकार के पैरामीटर के AsyncTask । 

class YourAsyncTask extends AsyncTask<URL, Integer, Long> {
    @Override
    protected void onProgressUpdate(Integer... args) {
        setProgressPercent(args[0])
    }
}

दूसरा, हमें doInBackground फ़ंक्शन पर आवश्यक रूप से फ़ंक्शन publishProgress का उपयोग करना होगा, और वह सब है, पिछली विधि सभी काम करेगी। 

protected Long doInBackground(URL... urls) {
     int count = urls.length;
     long totalSize = 0;
     for (int i = 0; i < count; i++) {
         totalSize += Downloader.downloadFile(urls[i]);
         publishProgress((int) ((i / (float) count) * 100));
     }
     return totalSize;
 }

Android में AsyncTask का उपयोग करके छवि डाउनलोड करें

यह ट्यूटोरियल बताता है कि Android में AsyncTask का उपयोग करके छवि को कैसे डाउनलोड किया जाए। डाउनलोड के दौरान प्रगति बार दिखाते समय डाउनलोड छवि के नीचे का उदाहरण।

Android AsyncTask को समझना

Async कार्य आपको थ्रेड में गंदे होने के बिना MultiThreading को कार्यान्वित करने में सक्षम बनाता है। AsyncTask UI थ्रेड का उचित और आसान उपयोग सक्षम करता है। यह पृष्ठभूमि संचालन और UI थ्रेड पर परिणाम पास करने की अनुमति देता है। यदि आप UI से संबंधित कुछ अलग कर रहे हैं, उदाहरण के लिए किसी सूची में प्रस्तुत करने के लिए डेटा डाउनलोड करना, आगे बढ़ें और AsyncTask का उपयोग करें।

  • AsyncTasks को लघु संचालन के लिए आदर्श रूप से उपयोग किया जाना चाहिए (कुछ सेकंड सबसे अधिक।)
  • एक एसिंक्रोनस कार्य को 3 सामान्य प्रकारों द्वारा परिभाषित किया जाता है, जिन्हें Params, Progress and Result, और 4 चरण, onPreExecute() , doInBackground() , onProgressUpdate() और onPostExecute() ।
  • onPreExecute() आप कोड को परिभाषित कर सकते हैं, जिसे पृष्ठभूमि प्रसंस्करण शुरू होने से पहले निष्पादित करने की आवश्यकता होती है।
  • doInBackground का कोड होता है जिसे पृष्ठभूमि में निष्पादित करने की आवश्यकता होती है, यहाँ doInBackground() हम कई बार परिणाम भेज सकते हैं ताकि पब्लिशप्रोग्रेस () विधि द्वारा थ्रेड को इवेंट प्रोसेसिंग के लिए भेजा जा सके, यह सूचित करने के लिए कि हम केवल परिणाम वापस कर सकते हैं।
  • onProgressUpdate() विधि से प्रगति अपडेट प्राप्त doInBackground() जो के माध्यम से प्रकाशित किया जाता है विधि, publishProgress() विधि, और इस विधि अद्यतन घटना धागा को यह प्रगति अद्यतन का उपयोग कर सकते
  • onPostExecute() विधि हैंडल परिणाम doInBackground() विधि द्वारा लौटाए जाते हैं।
  • उपयोग किए जाने वाले सामान्य प्रकार हैं
    • परिम, निष्पादन पर टास्क के लिए भेजे गए मापदंडों के प्रकार
    • प्रगति, पृष्ठभूमि संगणना के दौरान प्रकाशित प्रगति इकाइयों का प्रकार।
    • परिणाम, पृष्ठभूमि गणना के परिणाम का प्रकार।
  • यदि कोई async कार्य किसी भी प्रकार का उपयोग नहीं कर रहा है, तो इसे Void प्रकार के रूप में चिह्नित किया जा सकता है।
  • cancel(boolean) पद्धति को कॉल करके एक रनिंग एस्कॉन कार्य रद्द किया जा सकता है।

Android AsyncTask का उपयोग करके छवि डाउनलोड करना

अपने .xml लेआउट 

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout 
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >

<Button
    android:id="@+id/downloadButton"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:text="Click Here to Download" />

<ImageView
    android:id="@+id/imageView"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:contentDescription="Your image will appear here" />

</LinearLayout>

.जावा वर्ग 

package com.javatechig.droid;

import java.io.InputStream;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
import android.app.Activity;
import android.app.ProgressDialog;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.AsyncTask;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.ImageView;

public class ImageDownladerActivity extends Activity {

    private ImageView downloadedImg;
    private ProgressDialog simpleWaitDialog;
    private String downloadUrl = "http://www.9ori.com/store/media/images/8ab579a656.jpg";

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.asynch);
        Button imageDownloaderBtn = (Button) findViewById(R.id.downloadButton);

        downloadedImg = (ImageView) findViewById(R.id.imageView);

        imageDownloaderBtn.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                new ImageDownloader().execute(downloadUrl);
            }

        });
    }

    private class ImageDownloader extends AsyncTask {

        @Override
        protected Bitmap doInBackground(String... param) {
            // TODO Auto-generated method stub
            return downloadBitmap(param[0]);
        }

        @Override
        protected void onPreExecute() {
            Log.i("Async-Example", "onPreExecute Called");
            simpleWaitDialog = ProgressDialog.show(ImageDownladerActivity.this,
                    "Wait", "Downloading Image");

        }

        @Override
        protected void onPostExecute(Bitmap result) {
            Log.i("Async-Example", "onPostExecute Called");
            downloadedImg.setImageBitmap(result);
            simpleWaitDialog.dismiss();

        }

        private Bitmap downloadBitmap(String url) {
            // initilize the default HTTP client object
            final DefaultHttpClient client = new DefaultHttpClient();

            //forming a HttpGet request 
            final HttpGet getRequest = new HttpGet(url);
            try {

                HttpResponse response = client.execute(getRequest);

                //check 200 OK for success
                final int statusCode = response.getStatusLine().getStatusCode();

                if (statusCode != HttpStatus.SC_OK) {
                    Log.w("ImageDownloader", "Error " + statusCode + 
                            " while retrieving bitmap from " + url);
                    return null;

                }

                final HttpEntity entity = response.getEntity();
                if (entity != null) {
                    InputStream inputStream = null;
                    try {
                        // getting contents from the stream 
                        inputStream = entity.getContent();

                        // decoding stream data back into image Bitmap that android understands
                        final Bitmap bitmap = BitmapFactory.decodeStream(inputStream);

                        return bitmap;
                    } finally {
                        if (inputStream != null) {
                            inputStream.close();
                        }
                        entity.consumeContent();
                    }
                }
            } catch (Exception e) {
                // You Could provide a more explicit error message for IOException
                getRequest.abort();
                Log.e("ImageDownloader", "Something went wrong while" +
                        " retrieving bitmap from " + url + e.toString());
            } 

            return null;
        }
    }
}

चूंकि वर्तमान में उदाहरणों के लिए कोई टिप्पणी क्षेत्र नहीं है (या मुझे यह नहीं मिला है या मैंने इसके लिए अनुमति नहीं दी है) इस बारे में कुछ टिप्पणी है:

यह एक अच्छा उदाहरण है जो AsyncTask के साथ किया जा सकता है।

हालांकि उदाहरण के साथ वर्तमान में समस्याएं हैं

  • संभव स्मृति लीक
  • यदि ऐक्सिंक कार्य समाप्त होने से कुछ समय पहले स्क्रीन रोटेशन होता है तो ऐप क्रैश।

विवरण के लिए देखें:

मेमोरी लीक से बचने के लिए WeakReference के रूप में पास गतिविधि

AsyncTask के लिए यह गतिविधि के संदर्भ के लिए सामान्य है जिसे इसे कहा जाता है।

यदि AsyncTask गतिविधि का एक आंतरिक वर्ग है, तो आप इसे और किसी भी सदस्य चर / विधियों को सीधे संदर्भित कर सकते हैं।

यदि, हालांकि, AsyncTask गतिविधि का एक आंतरिक वर्ग नहीं है, तो आपको AsyncTask में गतिविधि संदर्भ पास करना होगा। जब आप ऐसा करते हैं, तो एक संभावित समस्या जो हो सकती है वह यह है कि AsyncTask गतिविधि का संदर्भ तब तक रखेगा जब तक कि AsyncTask ने अपने पृष्ठभूमि थ्रेड में अपना काम पूरा नहीं कर लिया। यदि गतिविधि समाप्त हो गई है या AsyncTask की पृष्ठभूमि थ्रेड कार्य पूरा होने से पहले ही मार दी गई है, तो AsyncTask में अभी भी गतिविधि का संदर्भ होगा, और इसलिए इसे कचरा एकत्र नहीं किया जा सकता है।

नतीजतन, यह एक मेमोरी लीक का कारण होगा।

ऐसा होने से रोकने के लिए, गतिविधि का सीधा संदर्भ होने के बजाय, AsyncTask में एक WeakReference का उपयोग करें।

यहाँ एक उदाहरण AsyncTask है जो एक कमजोर संदर्भ का उपयोग करता है: 

private class MyAsyncTask extends AsyncTask<String, Void, Void> {

    private WeakReference<Activity> mActivity;

    public MyAsyncTask(Activity activity) {
        mActivity = new WeakReference<Activity>(activity);
    }

    @Override
    protected void onPreExecute() {
        final Activity activity = mActivity.get();
        if (activity != null) {
            ....
        }
    }

    @Override
    protected Void doInBackground(String... params) {
        //Do something
        String param1 = params[0];
        String param2 = params[1];
        return null;
    }

    @Override
    protected void onPostExecute(Void result) {
        final Activity activity = mActivity.get();
        if (activity != null) {
            activity.updateUI();
        }
    }
}

किसी गतिविधि से AsyncTask को कॉल करना: 

new MyAsyncTask(this).execute("param1", "param2");

एक टुकड़े से AsyncTask कॉलिंग: 

new MyAsyncTask(getActivity()).execute("param1", "param2");

फाँसी का आदेश

जब पहली बार पेश किया गया था, तो AsyncTasks को एकल पृष्ठभूमि थ्रेड पर क्रमिक रूप से निष्पादित किया गया था। DONUT साथ शुरू करते DONUT , इसे थ्रेड्स के एक पूल में बदल दिया गया, जिससे कई कार्यों को समानांतर में संचालित किया जा सके। HONEYCOMB साथ शुरू, समानांतर निष्पादन के कारण होने वाली सामान्य अनुप्रयोग त्रुटियों से बचने के लिए कार्यों को एक ही थ्रेड पर निष्पादित किया जाता है।

यदि आप वास्तव में समानांतर निष्पादन चाहते हैं, तो आप executeOnExecutor(java.util.concurrent.Executor, Object[]) को THREAD_POOL_EXECUTOR ।

SERIAL_EXECUTOR -> एक निष्पादनकर्ता जो धारावाहिक क्रम में एक समय में कार्यों को निष्पादित करता है।

THREAD_POOL_EXECUTOR -> एक निष्पादनकर्ता जिसका उपयोग समानांतर में कार्यों को निष्पादित करने के लिए किया जा सकता है।

नमूना: 

Task task = new Task();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB)
    task.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR, data);
else
    task.execute(data);

AsyncTask: सीरियल एक्ज़िक्यूशन और टास्क के समानांतर निष्पादन

AsyncTask एक अमूर्त वर्ग है और यह Thread क्लास को इनहेरिट नहीं करता है। इसमें एक अमूर्त विधि doInBackground(Params... params) , जिसे कार्य करने के लिए ओवरराइड किया जाता है। इस विधि को AsyncTask.call() से कहा जाता है।

निष्पादक java.util.concurrent पैकेज का हिस्सा हैं।

इसके अलावा, AsyncTask 2 शामिल Executor रों

THREAD_POOL_EXECUTOR

यह समानांतर रूप से कार्यों को निष्पादित करने के लिए कार्यकर्ता थ्रेड्स का उपयोग करता है। 

public static final Executor THREAD_POOL_EXECUTOR = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

SERIAL_EXECUTOR

यह कार्य को क्रमबद्ध रूप से करता है, अर्थात एक-एक करके। 

private static class SerialExecutor implements Executor { }

दोनों Executor रों स्थिर हैं, इसलिए केवल एक THREAD_POOL_EXECUTOR और एक SerialExecutor वस्तुओं मौजूद हैं, लेकिन आप कई बना सकते हैं AsyncTask वस्तुओं।

इसलिए, यदि आप डिफ़ॉल्ट SerialExecutor ( SerialExecutor ) के साथ कई बैकग्राउंड टास्क करने की कोशिश करते हैं, तो ये टास्क कतारबद्ध रूप से और निष्पादित होगा।

यदि आप THREAD_POOL_EXECUTOR साथ कई पृष्ठभूमि कार्य करने का प्रयास करते हैं, तो उन्हें समानांतर रूप से निष्पादित किया जाएगा।

उदाहरण: 

public class MainActivity extends Activity {
    private Button bt;
    private int CountTask = 0;
    private static final String TAG = "AsyncTaskExample";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        bt = (Button) findViewById(R.id.button);
        bt.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                BackgroundTask backgroundTask = new BackgroundTask ();
                Integer data[] = { ++CountTask, null, null };

                // Task Executed in thread pool ( 1 )
                backgroundTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, data);

                // Task executed Serially ( 2 )
                // Uncomment the below code and comment the above code of Thread
                // pool Executor and check
                // backgroundTask.execute(data);
                Log.d(TAG, "Task = " + (int) CountTask + " Task Queued");

            }
        });

    }

    private class BackgroundTask extends AsyncTask<Integer, Integer, Integer> {
        int taskNumber;

        @Override
        protected Integer doInBackground(Integer... integers) {
            taskNumber = integers[0];

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            Log.d(TAG, "Task = " + taskNumber + " Task Running in Background");

            publishProgress(taskNumber);
            return null;
        }

        @Override
        protected void onPreExecute() {
            super.onPreExecute();
        }

        @Override
        protected void onPostExecute(Integer aLong) {
            super.onPostExecute(aLong);
        }

        @Override
        protected void onProgressUpdate(Integer... values) {
            super.onProgressUpdate(values);
            Log.d(TAG, "Task = " + (int) values[0]
                    + " Task Execution Completed");
        }
    }
}

कार्य शुरू करने और परिणाम देखने के लिए कई बार बटन पर क्लिक करें।

थ्रेड पूल में कार्य निष्पादन (1)

प्रत्येक कार्य को पूरा करने के लिए 1000 ms लगते हैं।

T = 36s पर, कार्य 2, 3 और 4 पंक्तिबद्ध हैं और उन्हें निष्पादित करना भी शुरू कर दिया है क्योंकि वे समानांतर रूप से निष्पादित कर रहे हैं। 

08-02 19:48:35.815: D/AsyncTaskExample(11693): Task = 1 Task Queued
08-02 19:48:35.815: D/AsyncTaskExample(11693): Task = 1 Task Running in Background
08-02 19:48:**36.025**: D/AsyncTaskExample(11693): Task = 2 Task Queued
08-02 19:48:**36.025**: D/AsyncTaskExample(11693): Task = 2 Task Running in Background
08-02 19:48:**36.165**: D/AsyncTaskExample(11693): Task = 3 Task Queued
08-02 19:48:**36.165**: D/AsyncTaskExample(11693): Task = 3 Task Running in Background
08-02 19:48:**36.325**: D/AsyncTaskExample(11693): Task = 4 Task Queued
08-02 19:48:**36.325**: D/AsyncTaskExample(11693): Task = 4 Task Running in Background
08-02 19:48:**36.815**: D/AsyncTaskExample(11693): Task = 1 Task Execution Completed
08-02 19:48:**36.915**: D/AsyncTaskExample(11693): Task = 5 Task Queued
08-02 19:48:**36.915**: D/AsyncTaskExample(11693): Task = 5 Task Running in Background
08-02 19:48:37.025: D/AsyncTaskExample(11693): Task = 2 Task Execution Completed
08-02 19:48:37.165: D/AsyncTaskExample(11693): Task = 3 Task Execution Completed
----------

टिप्पणी Task Executed in thread pool (1) और अनियंत्रित Task executed Serially (2) को Task executed Serially ।

कार्य शुरू करने और परिणाम देखने के लिए कई बार बटन पर क्लिक करें।

यह कार्य को क्रमानुसार निष्पादित कर रहा है इसलिए प्रत्येक कार्य को वर्तमान कार्य पूरा होने के बाद शुरू किया जाता है। इसलिए जब टास्क 1 का निष्पादन पूर्ण हो जाता है, तो केवल टास्क 2 पृष्ठभूमि में चलने लगता है। विपरीतता से। 

08-02 19:42:57.505: D/AsyncTaskExample(10299): Task = 1 Task Queued
08-02 19:42:57.505: D/AsyncTaskExample(10299): Task = 1 Task Running in Background
08-02 19:42:57.675: D/AsyncTaskExample(10299): Task = 2 Task Queued
08-02 19:42:57.835: D/AsyncTaskExample(10299): Task = 3 Task Queued
08-02 19:42:58.005: D/AsyncTaskExample(10299): Task = 4 Task Queued
08-02 19:42:58.155: D/AsyncTaskExample(10299): Task = 5 Task Queued
08-02 19:42:58.505: D/AsyncTaskExample(10299): Task = 1 Task Execution Completed
08-02 19:42:58.505: D/AsyncTaskExample(10299): Task = 2 Task Running in Background
08-02 19:42:58.755: D/AsyncTaskExample(10299): Task = 6 Task Queued
08-02 19:42:59.295: D/AsyncTaskExample(10299): Task = 7 Task Queued
08-02 19:42:59.505: D/AsyncTaskExample(10299): Task = 2 Task Execution Completed
08-02 19:42:59.505: D/AsyncTaskExample(10299): Task = 3 Task Running in Background
08-02 19:43:00.035: D/AsyncTaskExample(10299): Task = 8 Task Queued
08-02 19:43:00.505: D/AsyncTaskExample(10299): Task = 3 Task Execution Completed
08-02 19:43:**00.505**: D/AsyncTaskExample(10299): Task = 4 Task Running in Background
08-02 19:43:**01.505**: D/AsyncTaskExample(10299): Task = 4 Task Execution Completed
08-02 19:43:**01.515**: D/AsyncTaskExample(10299): Task = 5 Task Running in Background
08-02 19:43:**02.515**: D/AsyncTaskExample(10299): Task = 5 Task Execution Completed
08-02 19:43:**02.515**: D/AsyncTaskExample(10299): Task = 6 Task Running in Background
08-02 19:43:**03.515**: D/AsyncTaskExample(10299): Task = 7 Task Running in Background
08-02 19:43:**03.515**: D/AsyncTaskExample(10299): Task = 6 Task Execution Completed
08-02 19:43:04.515: D/AsyncTaskExample(10299): Task = 8 Task Running in Background
08-02 19:43:**04.515**: D/AsyncTaskExample(10299): Task = 7 Task Execution Completed


Modified text is an extract of the original Stack Overflow Documentation
के तहत लाइसेंस प्राप्त है CC BY-SA 3.0
से संबद्ध नहीं है Stack Overflow