Android asynchronous Processing

Original article to: http://www.pin5i.com/showtopic-android-asynctask-sample.html

Asynctask

It seems that the changed connect () method is available, but this method is anonymous.ThreadThere are defects: first, the thread overhead is large. If each task needs to create a thread, the applicationProgramSecond, the threads cannot be managed. After an anonymous thread is created and started, it is not controlled by the program. If many requests are sent, then a lot of threads will be started, and the system will be overwhelmed. In addition, we can see that the new thread is updated.UIHandler must also be introduced.CodeIt looks very bloated.

To solve this problem, ophone introduced asynctask in version 1.5. Asynctask is characterized by running tasks outside the main thread, and the callback method is executed in the main thread, which effectively avoids the trouble of using handler. According to the source code of asynctask, asynctask uses Java. util. concurrent.FrameworkConcurrent framework is a very mature and efficient framework for managing threads and task execution.Test. This shows that asynctask is designed to solve the problem of anonymous threads.

Asynctask is an abstract class. The subclass must implement the abstract method doinbackground (Params... P). In this method, the task is executed, such as connecting to the network to obtain data. Generally, the onpostexecute (result R) method should also be implemented, because the results that the application cares about are returned in this method. Note that asynctask must create instances in the main thread. 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 SS background tasks executed.
* Result: the result returned when a task is executed in the background, such as string.

Asynctask is executed in four steps, similar to the tasklistener defined earlier. Each step corresponds to a callback method. Note that these methods should not be called by the application. What developers need to do is to implement these methods. These methods are automatically called During task execution.

* Onpreexecute () This method is called before the task is executed. The progress dialog box is displayed here.
* Doinbackground (Params...) This method is executed in the background thread to complete the main work of the task, which usually takes a long time. During execution, you can call publicprogress (Progress...) to update the task progress.
* Onprogressupdate (Progress...) is executed in the main thread to display the task execution progress.
* Onpostexecute (result) This method is executed in the main thread, and the task execution result is returned as a parameter of this method.

Pagetask extends asynctask to read the webpage content in the doinbackground () method. PagetaskSource codeAs follows:

2. // Set three types of parameters: String, integer, and string.
4. Class pagetask extends asynctask <string, integer, string> {
6.  
8. // Variable length input parameter, which corresponds to asynctask. exucute ()
10. @ Override
12. Protected string doinbackground (string... Params ){
14. Try {
16. Httpclient client = new defaulthttpclient ();
18. // Params [0] indicates the URL of the connection.
20. Httpget = new httpget (Params [0]);
22. Httpresponse response = client.exe cute (get );
24. Httpentity entity = response. getentity ();
26. Long length = entity. getcontentlength ();
28. Inputstream is = entity. getcontent ();
30. String S = NULL;
32. If (is! = NULL ){
34. Bytearrayoutputstream baos = new bytearrayoutputstream ();
36. Byte [] Buf = new byte [1, 128];
38. Int CH =-1;
40. Int COUNT = 0;
42. While (CH = is. Read (BUF ))! =-1 ){
44. Baos. Write (BUF, 0, CH );
46. Count + = CH;
48. If (length> 0 ){
50. // If you know the response length, call publishprogress () to update the progress.
52. Publishprogress (INT) (count/(float) length) * 100 ));
54. }
56. // To clearly view the progress in the simulator, sleep the thread for 100 ms
58. Thread. Sleep (100 );
60. }
62. S = new string (baos. tobytearray ());}
64. // Return results
66. Return S;
68. } Catch (exception e ){
70. E. printstacktrace ();
72. }
74. Return NULL;
76. }
78. @ Override
80. Protected void oncancelled (){
82. Super. oncancelled ();
84. }
86. @ Override
88. Protected void onpostexecute (string result ){
90. // Return the HTML page content
92. Message. settext (result );
94. }
96. @ Override
98. Protected void onpreexecute (){
100. // Start the task. A dialog box is displayed here, which is simple.
102. Message. settext (R. String. task_started );
104. }
106. @ Override
108. Protected void onprogressupdate (integer... values ){
110. // Update Progress
112. Message. settext (Values [0]);
114. }
116. }

Copy code

Executing pagetask is very simple. You only need to call the following code. Re-run networkactivity to capture the webpage content and update the reading progress in real time. The reader tries to read a large web page to check the Update Progress of the percentage.

1. Pagetask task = new pagetask ();
2. Task.exe cute (URL. gettext (). tostring ());

Copy code