AsyncTask是android提供的轻量级的异步类,要利用AsyncTask工作我们要提供三个泛型参数

  // 设置二种档次参数分别为String,Integer,String  
  class TaskTest extends AsyncTask<String, Integer, String> { 
         // 可变长的输入参数,与AsyncTask.exucute()对应
         @Override  
         protected String doInBackground(String… params) {  
             try {  
                 HttpClient client = new DefaultHttpClient();  
                 // params[0] 代表连接的url  
                 HttpGet get = new HttpGet(params[0]);  
                 HttpResponse response = client.execute(get);  
                 HttpEntity entity = response.getEntity();  
                 long length = entity.getContentLength();  
                 InputStream is = entity.getContent();  
                 String s = null;  
                 if (is != null) {  
                     ByteArrayOutputStream baos = new
ByteArrayOutputStream();  
                     byte[] buf = new byte[128];  
                     int ch = -1;  
                     int count = 0;  
                     while ((ch = is.read(buf)) != -1) {  
                         baos.write(buf, 0, ch);  
                         count += ch;  
                         if (length > 0) {  
                             //
要是掌握响应的长度,调用publishProgress()更新速度
                             publishProgress((int) ((count / (float)
length) * 100));  
                         }  
                         // 线程休眠100ms  
                         Thread.sleep(100);  
                     }  
                     s = new String(baos.toByteArray());            

(1)doInBackground(Void…
Params)后台执行,相比较耗时的操作都得以放在此处。注意那里不可能直接操作UI。此方法在后台线程执行,完毕职分的主要工作,日常要求较长的时光。在实践进度中得以调用publishProgress(Void…
values)来更新任务的速度。

 当一个先后第四回启动时,Android会同时起步一个遥相呼应的主线程(Main
Thread),主线程首要负责处理与UI相关的事件,如:用户的按键事件,用户接触屏幕的风云以及显示屏绘图事件,并把有关的轩然大波分发到对应的零部件举行拍卖。所以主线程平常又被称之为UI线程。 

(1)onProgressUpdate(Void…
values) 可以利用过程条增添用户体验度。此方式在主线程执行,用于展现职务履行的速度。

        }
                 // 重回结果 
                 return s; 
             } catch (Exception e) { 
                 e.printStackTrace(); 
             } 
             return null; 
         } 
         @Override 
         protected void onCancelled() { 
             super.onCancelled(); 
         } 
         @Override 
         protected void onPostExecute(String result) { 
             // 重临HTML页面的始末 
             message.setText(result); 
         } 
         @Override 
         protected void onPreExecute() { 
             // 职责启动,可以在此间体现一个会话框,这里大致处理 
             message.setText(R.string.task_started); 
         } 
         @Override 
         protected void onProgressUpdate(Integer… values) { 
             // 更新速度 
             message.setText(values[0]); 
         } 
     }

protected void onProgressUpdate(Integer… values) {

利用AsyncTask异步加载数据最少要重写以下那七个办法:

AsyncTask是android提供的轻量级的异步类,可以平素接轨AsyncTask,在类中贯彻异步操作,并提供接口反馈当前异步执行的水平(可以经过接口完毕UI进程更新),末了汇报执行的结果给UI主线程。

 第二个参数:传入doInBackground()方法的参数类型 

(3)onCancelled()  用户调用撤消时,要做的操作。

(4)该task只好被实施三遍,否则很多次调用时将会出 

import android.widget.TextView;

(1)Params 启动义务执行的输入参数,比如HTTP请求的URL。

利用AsyncTask异步加载数据最少要重写以下那八个情势:

 * doInBackground(Params…), 将在onPreExecute
方法执行后立即执行,该方法运行在后台线程中。那里将紧要负责实施那个很耗时的后台处理工作。可以调用
publishProgress方法来更新实时的天职进程。该格局是空虚方法,子类必须贯彻。 

选择AsyncTask类,以下是几条必须遵守的守则:

(3)onCancelled() 
用户调用撤除时,要做的操作。

if(length > 0) {

(3)不要手动的调用onPreExecute(),
onPostExecute(Result),doInBackground(Params…),
onProgressUpdate(Progress…)那多少个法子

 

// 重临结果

(1)Task的实例必须在UI thread中成立

行使AsyncTask类,以下是几条必须遵循的规则:

});

简短示例代码:

(2)Progress
后台职分执行的百分比。

Thread.sleep(100);

(2)Progress 后台任务执行的比例。

(2)onPreExecute()
那是最终用户调用Execute时的接口,当义务执行从前初步调用此方法,可以在那里彰显速度对话框。

 @Override 

有必不可少的话仍可以重写以下五个主意,但不是必须的:

(2)execute方法必须在UI
thread中调用

return s;

        }
                 // 再次回到结果  
                 return s;  
             } catch (Exception e) {  
                 e.printStackTrace();  
             }  
             return null;  
         }  
         @Override  
         protected void onCancelled() {  
             super.onCancelled();  
         }  
         @Override  
         protected void onPostExecute(String result) {  
             // 重临HTML页面的内容  
             message.setText(result);  
         }  
         @Override  
         protected void onPreExecute() {  
             // 职责启动,可以在此处突显一个对话框,那里大约处理  
             message.setText(R.string.task_started);  
         }  
         @Override  
         protected void onProgressUpdate(Integer… values) {  
             // 更新速度  
             message.setText(values[0]);  
         }  
     }

AsyncTask直接接轨于Object类,地方为android.os.AsyncTask。要运用AsyncTask工作大家要提供多个泛型参数,不分相互载多少个主意(至少重载一个)。

// 可变长的输入参数,与AsyncTask.exucute()对应

AsyncTask定义了三种泛型类型 Params,Progress和Result。

 

String s = null;

AsyncTask是android提供的轻量级的异步类,可以一直接轨AsyncTask,在类中贯彻异步操作,并提供接口反馈当前异步执行的水平(可以由此接口完结UI进程更新),最后汇报执行的结果给UI主线程。

有要求的话仍能重写以下多少个章程,但不是必须的:

import org.apache.http.HttpResponse;

AsyncTask直接接轨于Object类,地点为android.os.AsyncTask。要运用AsyncTask工作大家要提供多少个泛型参数,天公地道载几个办法(至少重载一个)。

(3)Result
后台执行任务最后回到的结果,比如String。

 首个参数:传入onProgressUpdate()方法的参数类型 

(4)该task只好被执行四次,否则多次调用时将会出 

简言之示例代码:

在开发Android应用时务必听从单线程模型的尺码:

(2)execute方法必须在UI thread中调用

(1)Params
启动职责执行的输入参数,比如HTTP请求的URL。

 * onPreExecute()
当义务履行此前早先调用此形式,可以在这边显示速度对话框。

(3)Result 后台执行职务最终回到的结果,比如String。

(3)不要手动的调用onPreExecute(),
onPostExecute(Result),doInBackground(Params…),
onProgressUpdate(Progress…)那多少个艺术

// 让线程休眠100ms

(2)onPostExecute(Void
Result)相当于Handler处理UI的方法,在那中间可以行使在doInBackground得到的结果处理操作UI。此措施在主线程执行,任务执行的结果作为此方法的参数重返。

(1)Task的实例必须在UI
thread中创设

 } 

(1)doInBackground(Void…
Params)后台执行,相比耗时的操作都可以置身那里。注意那里不可以一贯操作UI。此办法在后台线程执行,落成职责的严重性工作,经常须要较长的日子。在执行进度中可以调用publishProgress(Void…
values)来更新任务的进度。

(1)onProgressUpdate(Void…
values) 可以应用进程条扩张用户体验度。此措施在主线程执行,用于体现职分执行的进程。

long length = entity.getContentLength();

 

  //
设置三种档次参数分别为String,Integer,String 
  class TaskTest extends AsyncTask<String, Integer, String> { 
         // 可变长的输入参数,与AsyncTask.exucute()对应
         @Override 
         protected String doInBackground(String… params) { 
             try { 
                 HttpClient client = new DefaultHttpClient(); 
                 // params[0] 代表连接的url 
                 HttpGet get = new HttpGet(params[0]); 
                 HttpResponse response = client.execute(get); 
                 HttpEntity entity = response.getEntity(); 
                 long length = entity.getContentLength(); 
                 InputStream is = entity.getContent(); 
                 String s = null; 
                 if (is != null) { 
                     ByteArrayOutputStream baos = new
ByteArrayOutputStream(); 
                     byte[] buf = new byte[128]; 
                     int ch = -1; 
                     int count = 0; 
                     while ((ch = is.read(buf)) != -1) { 
                         baos.write(buf, 0, ch); 
                         count += ch; 
                         if (length > 0) { 
                             //
倘使精晓响应的长度,调用publishProgress()更新速度
                             publishProgress((int) ((count / (float)
length) * 100)); 
                         } 
                         // 线程休眠100ms 
                         Thread.sleep(100); 
                     } 
                     s = new String(baos.toByteArray());            

2) execute方法必须在UI 线程中调用

(2)onPreExecute()
这是最终用户调用Execute时的接口,当职责履行从前起初调用此形式,可以在此间浮现速度对话框。

(2)onPostExecute(Void
Result)相当于Handler处理UI的点子,在那中间可以行使在doInBackground获得的结果处理操作UI。此措施在主线程执行,使命执行的结果作为此方法的参数再次来到。

import java.io.ByteArrayOutputStream;

AsyncTask定义了三种泛型类型
Params,Progress和Result。

}

 

import android.app.Activity;

System.out.println(“”+values[0]);

pdialog.show();

import android.content.DialogInterface;

}

import android.os.AsyncTask;

 * onProgressUpdate(Progress…),在publishProgress方法被调用后,UI
线程将调用那一个法子从而在界面上彰显职务的开展情形,例如通过一个进程条举办浮现。 

 Android
UI操作并不是线程安全的还要那些操作必须在UI线程中执行。在单线程模型中一贯要铭记在心两条法则:

}

import android.os.Message;

 private TextView message; 

onProgressUpdate(Progress…),在publishProgress方法被调用后,UI
thread将调用那么些办法从而在界面上出示职分的展开情状,例如通过一个进程条举办展示。

pdialog.setCancelable(true);

import org.apache.http.impl.client.DefaultHttpClient;

AsyncTask的三个泛型参数说明(八个参数可以是任何项目) 

Hanlder 

protected void onCancelled() {

message.setText(“”+values[0]);

 private void connect() { 

s = new String(baos.toByteArray());              }

//第一个String代表处理进度中的参数类型,也就是doInBackground()执行进程中的产出参数类型,通过publishProgress()发信息//传递给onProgressUpdate()一般用来更新界面

 * AsyncTask是空泛类.AsyncTask定义了两种泛型类型
Params,Progress和Result。  * Params
启动义务履行的输入参数,比如HTTP请求的URL。  

}

message.setText(R.string.task_started);

4) 该task只可以被实施五遍,否则多次调用时将会出现非凡 

 AsyncTask
的执行分为八个步骤,每一步都对应一个回调方法,要求注意的是这几个艺术不应有由应用程序调用,开发者须要做的就是落实这么些方式。在职分的实践进度中,这一个方法被活动调用。 

 * doInBackground(Params…) 此方法在后台线程
执行,已毕任务的要紧工作,平时必要较长的时辰。在推行进度中可以调用publicProgress(Progress…)来更新任务的速度。

import android.widget.Button;

message.setText(result);

1) 子类化AsyncTask

publishProgress((int) ((count / (float) length) * 100));

return null;

 为了化解那么些问题,Android
1.5提供了一个工具类:AsyncTask,它使创办需求与用户界面交互的长日子运作的天职变得更简明。相对来说AsyncTask更轻量级一些,适用于不难的异步处理,不需求依靠线程和Handler即可落成。

int count = 0;

 * onPostExecute(Result) 此方法在主线程
执行,职责执行的结果作为此办法的参数重返 

 * Result 后台执行职分最后回到的结果,比如String,Integer等。

finish();

HttpClient client = new DefaultHttpClient();

 * onProgressUpdate(Progress…) 此方法在主线程
执行,用于展现职分执行的快慢。

 } 

pdialog.setOnCancelListener(new DialogInterface.OnCancelListener() {

这个类或方法同样会使您的代码很复杂很难掌握。但是当你必要落成部分很复杂的操作并索要反复地更新UI时那会变得更不好。 

// 重返HTML页面的情节

}

 2. 管教只在UI线程中走访Android UI工具包 

import java.io.InputStream;

android提供了两种在其它线程中访问UI线程的主意。 

}

1) Task的实例必须在UI thread中开创

 View.postDelayed( Runnable, long ) 

InputStream is = entity.getContent();

 *
AsyncTask的进行分为八个步骤,每一步都对应一个回调方法,开发者须要完结这一个点子。  

 PageTask task = new PageTask(this);

try{

}

 message= (TextView) findViewById(R.id.message);

baos.write(buf, 0, ch);

3) 不要手动的调用onPreExecute(),
onPostExecute(Result),doInBackground(Params…),
onProgressUpdate(Progress…)那多少个点子

}

 });

 task.execute(url.getText().toString());

=============================再来就是用法:=========================================

 * Progress 后台职分执行的比例。

}

 public void onCreate(Bundle savedInstanceState) { 

从网上获取一个网页,在一个TextView军长其源代码展现出来复制代码package
test.list;import

import android.os.Bundle;

 *
android的类AsyncTask对线程间通讯进行了打包,提供了简单的编程形式来使后台线程和UI线程举办报导:后台线程执行异步任务,并把操作结果文告UI线程。 

        在开发Android移动客户端的时候屡次要使用多线程来开展操作,我们普通会将耗时的操作放在单独的线程执行,幸免其占据主线程而给用户带来不好的用户体验。不过在子线程中不能去操作主线程(UI
线程),在子线程中操作UI线程会产出错误。因而android提
供了一个类Handler来在子线程中来更新UI线程,用发信息的建制更新UI界面,显示给用户。那样就化解了子线程更新UI的难点。但是讨厌的职分操作
总会启动一些匿名的子线程,太多的子线程给系统带来巨大的承负,随之带来一些属性难点。由此android提供了一个工具类AsyncTask,顾名思义
异步执行职分。那么些AsyncTask生来就是拍卖部分后台的相比耗时的职分,给用户带来出色用户体验的,从编程的语法上出示淡雅了不少,不再要求子线程
和Handler就可以完毕异步操作并且刷新用户界面。

 先大约认识下Android.os.AsyncTask类:

 public void onClick(View arg0) { 

}

 super.onCreate(savedInstanceState); 

4) 该task只可以被执行两遍,否则数十次调用时将会出现非常 

pdialog.setMax(100);

}

pdialog.setButton(“cancel”, new DialogInterface.OnClickListener() {

//第几个String代表职务达成的面世类型,也就是doInBackground()的归来值类型,和onPostExecute()的参数类型private
class task extends AsyncTask<String, String, String>

 url= (EditText) findViewById(R.id.url); 

doInBackground(Params…), 将在onPreExecute
方法执行后及时执行,该措施运行在后台线程中。那里将根本负责实施那多少个很耗时的后台总计工作。可以调用
publishProgress方法来更新实时的天职进程。该办法是虚幻方法,子类必须贯彻。
   

}

 private Button open; 

import android.app.ProgressDialog;

 View.post( Runnable )

protected void onPostExecute(String result) {

@Override

protected String doInBackground(String… params) {

pdialog.setProgress(values[0]);

1) Task的实例必须在UI 线程中开创

Activity.runOnUiThread( Runnable )

pdialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);

import android.os.Handler;

int ch = -1;

AsyncTask定义了二种泛型类型Params,Progress和Result。

常备还应该完成onPostExecute(Result r)
方法,因为应用程序关怀的结果在此措施中回到。必要小心的是AsyncTask一定要在主线程中创造实例。

2) execute方法必须在UI thread中调用

import org.apache.http.client.methods.HttpGet;

 doInBackground方法和onPostExecute的参数必须呼应,那多少个参数在AsyncTask申明的泛型参数列表中指定,第四个为doInBackground接受的参数,第四个为浮现速度的参数,第第多个为doInBackground重临和onPostExecute传入的参数。

@Override

* 1) 继承AsyncTask  

2) 已毕AsyncTask中定义的上面一个或多少个点子 

public void onCancel(DialogInterface dialog) {

在主线程中调用onCancelled()的时候调用。为了科学的拔取AsyncTask类,以下是几条必须听从的规则:

3) 不要手动的调用onPreExecute(),
onPostExecute(Result),doInBackground(Params…),
onProgressUpdate(Progress…)那多少个艺术,必要在UI线程中实例化这个task来调用。

  onPreExecute(), 该办法将在履行实际的后台操作前被UI
thread调用。可以在该格局中做一些准备干活,如在界面上显示一个进程条。
   

@Override

//第四个String代表输入到任务的参数类型,也即是doInBackground()的参数类型

 } 

super.onCancelled();

// 职分启动,可以在此间突显一个会话框,这里大约处理

 * Progress 后台任务执行的比重。  

 class PageTask extends AsyncTask{

@Override

HttpEntity entity = response.getEntity();

}

import org.apache.http.client.HttpClient;

e.printStackTrace();

public void onClick(DialogInterface dialog, int i) {

} catch(Exception e) {

 AsyncTask是画个饼来解除饥饿类.AsyncTask定义了二种泛型类型
Params,Progress和Result。Params
启动职分执行的输入参数,比如HTTP请求的URL。Progress
后台任务执行的比例。Result 后台执行职责最后回到的结果,比如String。
AsyncTask的推行分为七个步骤,每一步都对应一个回调方法,那些点子不应有由应用程序调用,开发者需求做的就是促成这么些措施。 

count += ch;

import android.widget.EditText;

// 如果通晓响应的尺寸,调用publishProgress()更新速度

// 更新速度

protected void onPreExecute() {

 比如说从网上获取一个网页,在一个TextView司令员其源代码呈现出来,那种涉及到网络操作的主次一般都是急需开一个线程落成网络访问,可是在取得页面源码后,是不可能平素在互联网操作线程中调用TextView.setText()的.因为其余线程中是不可以直接访问主UI线程成员

 * onPostExecute(Result), 在doInBackground 执行到位后,onPostExecute
方法将被UI 线程调用,后台的总括结果将因而该格局传递到UI
线程,并且在界面上展现给用户. 

if(is != null) {

 open= (Button) findViewById(R.id.open); 

 //AsyncTask<>的参数类型由用户设定,那里设为四个String

 * Result 后台执行职责最后回到的结果,比如String。 

// params[0]代表连接的url

HttpGet get = new HttpGet(params[0]);

pdialog = new ProgressDialog(context, 0);

 connect();

public PageTask(Context context){

});

为了科学的采取AsyncTask类,以下是几条必须遵从的守则:

AsyncTaskAsyncTask是抽象类,子类必须兑现抽象方法doInBackground(Params…
p) ,在此方法中完成职分的施行工作,比如总是互联网获取数据等。 

import android.content.Context;

dialog.cancel();

byte[] buf = new byte[128];

import org.apache.http.HttpEntity;

本文章:http://blog.csdn.net/webgeek/article/details/17298237

import java.util.ArrayList;

 onPostExecute(Result), 在doInBackground 执行到位后,onPostExecute
方法将被UI thread调用,后台的估量结果将透过该格局传递到UI thread. 

pdialog.dismiss();

 private EditText url; 

@Override

 open.setOnClickListener(new View.OnClickListener() { 

public class NetworkActivity extends Activity{ 

 * Params 启动职务执行的输入参数,比如HTTP请求的URL。

while((ch = is.read(buf)) != -1) {

 第两个参数:传入onPostExecute()方法的参数类型,也是doInBackground()方法再次来到的门类

import android.view.View;

HttpResponse response = client.execute(get);

 * onCancelled(),在用户裁撤线程操作的时候调用。

 doInBackground方法和onPostExecute的参数必须呼应,那四个参数在AsyncTask表明的泛型参数列表中指定,第四个为
doInBackground接受的参数,首个为体现速度的参数,第第五个为doInBackground重临和onPostExecute传入的参
数。

ByteArrayOutputStream baos = new ByteArrayOutputStream();

 1. 毫不阻塞UI线程

 * 2) 完成AsyncTask中定义的上边一个或多少个法子 * onPreExecute(),
该办法将在实践实际的后台操作前被UI
线程调用。可以在该措施中做一些准备干活,如在界面上出示一个进程条,或者局地控件的实例化,这几个主意能够毫无落成。 

 setContentView(R.layout.network);

ProgressDialog pdialog;

相关文章