Introduction to Android asynctask

Comparison between asynctask and handler

1) asynctask implementation principle, and applicable advantages and disadvantages

Asynctask is a lightweight asynchronous class provided by Android. It can inherit asynctask directly and implement asynchronous operations in the class,AndProvide interface feedback to the currentAsynchronous execution degree(Ui progress update can be implemented through the interface), and finally the execution result is fed back to the main UI thread.

Advantages:

L simple and fast

L process controllable

Disadvantages:

L it becomes complicated when multiple asynchronous operations and UI changes are required.

2) principle and advantages and disadvantages of handler asynchronous implementation

When handler is implemented asynchronously, it involves four objects: handler, logoff, message, and thread. the asynchronous process is that the main thread starts thread (subthread) à thread (subthread) run and generate message-à logoff to get the message and pass it to handler. the handler gets the message in logoff one by one and changes the UI.

Advantages:

L clear structure and clear Function Definition

L simple and clear for multiple background tasks

Disadvantages:

L when asynchronous processing is performed on a single backendCodeToo many, too complex structure (relative)

Introduction to asynctask Android asynctask is more lightweight than handler and is suitable for simple asynchronous processing. First, it is clear that android has handler and asynctask to avoid blocking the main thread (ui thread), and UI Updates can only be completed in the main thread, so asynchronous processing is inevitable.

Android provides asynctask to reduce the development difficulty. Asynctask is a encapsulated background task class. as its name implies, it is an asynchronous task.

Asynctask directly inherits from the object class and is located in Android. OS. asynctask. To use asynctask, we need to provide three generic parameters and reload several methods (at least one ).

 

Asynctask defines three generic types: Params, SS, and result.

• Input parameters for Params startup task execution, such as the URL of the HTTP request.
• Percentage of progress background tasks.
• Result: The result returned when the task is executed in the background, such as string.

All the students who have used asynctask know that the following two methods are required to load data asynchronously:

• Doinbackground (Params ...) The operations in the background can be put here. Note that you cannot directly operate the UI here. This method is executed in the background thread to complete the main work of the task, usually takes a long time. You can call publicprogress (progress…) during execution ...) To update the task progress.
• Onpostexecute (result) is equivalent to handler's way of processing the UI, where you can use the result processing operation UI obtained in doinbackground. This method is executed in the main thread. The task execution result is returned as a parameter of this method.

If necessary, you have to rewrite the following three methods, but they are not required:

• Onprogressupdate (progress ...) You can use the progress bar to increase user experience. This method is executed in the main thread to display the task execution progress.
• Onpreexecute () is the interface used by the end user to call excute. This method is called before the task is executed. The progress dialog box is displayed here.
• Oncancelled () the operation to be performed when the call is canceled

When using the asynctask class, the following guidelines must be followed:

• Task instances must be created in the UI thread;
• The execute method must be called in the UI thread;
• Do not manually call the onpreexecute (), onpostexecute (result), doinbackground (Params...), onprogressupdate (Progress...) methods;
• This task can only be executed once. Otherwise, exceptions may occur during multiple calls;

An example of a simple understanding of asynctask:

Main. xml

[Java] View plaincopy

2. <? XML version ="1.0"Encoding ="UTF-8"?>
4. <Linearlayout xmlns: Android =Http://schemas.android.com/apk/res/android"
6. Android: Orientation ="Vertical"
8. Android: layout_width ="Fill_parent"
10. Android: layout_height ="Fill_parent"
12. >
14. <Textview
16. Android: Id ="@ + ID/textview01"
18. Android: layout_width ="Fill_parent"
20. Android: layout_height ="Wrap_content"
22. />
24. <Progressbar
26. Android: Id ="@ + ID/progressbar02"
28. Android: layout_width ="Fill_parent"
30. Android: layout_height ="Wrap_content"
32. Style ="? Android: ATTR/progressbarstylehorizontal"
34. />
36. <Button
38. Android: Id ="@ + ID/button03"
40. Android: layout_width ="Fill_parent"
42. Android: layout_height ="Wrap_content"
44. Android: text ="Update progressbar"
46. />
48. </Linearlayout>

Mainactivity. Java

[HTML] View plaincopy

2. Package Vic. Wong. Main;
6. Import Android. App. activity;
8. Import Android. OS. Bundle;
10. Import Android. View. view;
12. Import Android. View. View. onclicklistener;
14. Import Android. widget. Button;
16. Import Android. widget. progressbar;
18. Import Android. widget. textview;
22. Public class mainactivity extends activity {
24. Private button;
26. Private progressbar;
28. Private textview;
32. @ Override
34. Public void oncreate (bundle savedinstancestate ){
36. Super. oncreate (savedinstancestate );
38. Setcontentview (R. layout. Main );
42. Button= (Button) findviewbyid (R. Id. button03 );
44. Progressbar= (Progressbar) findviewbyid (R. Id. progressbar02 );
46. Textview= (Textview) findviewbyid (R. Id. textview01 );
50. Button. setonclicklistener (New onclicklistener (){
54. @ Override
56. Public void onclick (view v ){
58. ProgressbarasynctaskAsynctask=NewProgressbarasynctask (textview, progressbar );
60. Asynctask.exe cute (1000 );
62. }
64. });
66. }
68. }

 

Netoperator. Java

[HTML] View plaincopy

2. Package Vic. Wong. Main;
8. // Simulate the Network Environment
10. Public class netoperator {
14. Public void operator (){
16. Try {
18. // Sleep for 1 second
20. Thread. Sleep (1000 );
22. } Catch (interruptedexception e ){
24. // Todo auto-generated Catch Block
26. E. printstacktrace ();
28. }
30. }
34. }

 

Progressbarasynctask. Java

[HTML] View plaincopy

2. Package Vic. Wong. Main;
4. Import Android. OS. asynctask;
6. Import Android. widget. progressbar;
8. Import Android. widget. textview;
12. /**
14. * After the class object is generated and the execute method is called
16. * The onproexecute method is executed first.
18. * Second, execute the doinbackgroup method.
20. *
22. */
24. Public class progressbarasynctask extends asynctask<Integer, Integer, string>{
28. Private textview;
30. Private progressbar;
36. Public progressbarasynctask (textview, progressbar ){
38. Super ();
40. This. textview= Textview;
42. This. progressbar= Progressbar;
44. }
50. /**
52. * The integer parameter corresponds to the first parameter in asynctask.
54. * The string return value corresponds to the third parameter of asynctask.
56. * This method is not run in the UI thread and is mainly used for asynchronous operations. All spaces in the UI cannot be set or modified in this method.
58. * However, you can call publishprogress to trigger onprogressupdate to operate the UI.
60. */
62. @ Override
64. Protected string doinbackground (integer... Params ){
66. NetoperatorNetoperator=NewNetoperator ();
68. IntI=0;
70. For (I=10; I<= 100; I + = 10 ){
72. Netoperator. Operator ();
74. Publishprogress (I );
76. }
78. Return I + Params [0]. intvalue () + "";
80. }
86. /**
88. * The string parameter corresponds to the third parameter in asynctask (that is, receiving the return value of doinbackground)
90. * After the doinbackground method is executed, it runs in the UI thread. You can set the UI space.
92. */
94. @ Override
96. Protected void onpostexecute (string result ){
98. Textview. settext ("Asynchronous Operation execution ends" + result );
100. }
106. // This method runs in the UI thread and can be set in the UI thread.
108. @ Override
110. Protected void onpreexecute (){
112. Textview. settext ("Starting asynchronous thread execution ");
114. }
120. /**
122. * The intege parameter corresponds to the second parameter in asynctask.
124. * In the doinbackground method, each call to the publishprogress method triggers the onprogressupdate execution.
126. * Onprogressupdate is executed in the UI thread. All operations can be performed on the UI space.
128. */
130. @ Override
132. Protected void onprogressupdate (integer... values ){
134. IntVlaue=Values[0];
136. Progressbar. setprogress (vlaue );
138. }
150. }