AsyncTask的注意事项

asyncTask的执行顺序

在execute执行的参数，传递进来的参数作为doInBackground,String 传递进来的第一个参数，

先调用PreExcute的操作，然后调用doInBackground的方法开始真正的异步操作原理，最后返回指定的类（onPostexecute）里面.

doBackground 开启异步线程进行操作的，基本属于耗时的操作

onPreExecute 线程开启之前的操作

前面设置的返回值设置的参数为Bitmap<String ,Void,Bitmap>,前面调用doInBackground后返回Bitmap的值,所以在onPostExcute返回的值为Bitmap,可以去设置UI。

1.获取传递进来的参数 String url=params[0]只获取第一位参数

2.网络的操作，BitmapFactory.decodeStream 将输入流解析成Bitmap

3.将Bitmap作为返回值

AsynckTask 加载图片

他的执行顺序

onPreExcute执行前的方法

doInBackground  执行中的方法

onPostExcute 执行后的方法

AsynckTask的异步参数,和四种方法

//Main.java:

public class Main extends AppCompatActivity {
    ImageView imageView;
    ProgressBar progressBar;
    ProgressBar progressBar2;
    TextView jishu, hint;
    static Handler myHandler;
    ImageLoad i1;
    Button btn;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        imageView = (ImageView) findViewById(R.id.imageView);
        progressBar = (ProgressBar) findViewById(R.id.progressBar);
        progressBar2 = (ProgressBar) findViewById(R.id.progressBar2);
        jishu = (TextView) findViewById(R.id.textView);
        hint = (TextView) findViewById(R.id.tv);
        i1 = new ImageLoad(imageView, progressBar, progressBar2);
        btn = (Button) findViewById(R.id.button);
    }

    @Override
    protected void onPause() {
        super.onPause();
        if (i1 != null && i1.getStatus() == AsyncTask.Status.RUNNING) {
            i1.cancel(true);
        }
    }

    public void startload(View v) {
        btn.setEnabled(false);
        jishu.setVisibility(View.VISIBLE);
        myHandler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                jishu.setText("Loading:" + msg.arg1 + "%");
                if (msg.arg1 == 100) {
                    jishu.setVisibility(View.INVISIBLE);
                    btn.setVisibility(View.INVISIBLE);
                    hint.setVisibility(View.VISIBLE);
                }
            }
        };
        i1.execute("https://ss0.bdstatic.com/70cFvHSh_Q1YnxGkpoWK1HF6hhy/it
        /u=3651717973,1621948329&fm=26&gp=0.jpg");
    }

}


//ImageLoad.java:

public class ImageLoad extends AsyncTask<String, Integer, Bitmap> {
    ImageView imageView;
    ProgressBar progressBar;
    ProgressBar progressBar2;
    static Message msg;

    public ImageLoad(ImageView imageView, ProgressBar progressBar, ProgressBar progressBar2) {
        this.imageView = imageView;
        this.progressBar = progressBar;
        this.progressBar2 = progressBar2;
    }

    @Override
    protected void onPreExecute() {
        super.onPreExecute();
        progressBar.setVisibility(View.VISIBLE);
        progressBar2.setVisibility(View.VISIBLE);
    }

    @Override
    protected Bitmap doInBackground(String... params) {
        Bitmap bitmap = null;
        HttpURLConnection conn;
        InputStream is;
        String url = params[0];

        try {
            conn = (HttpURLConnection) new URL(url).openConnection();
            is = conn.getInputStream();
            BufferedInputStream bis = new BufferedInputStream(is);
            for (int i = 0; i < 100; i++) {
                if (isCancelled()) {
                    break;
                }
                publishProgress(i);
                msg = Main.myHandler.obtainMessage();
                msg.arg1 = i + 1;
                Main.myHandler.sendMessage(msg);
                Thread.sleep(25);
            }
            bitmap = BitmapFactory.decodeStream(is);
            is.close();
            bis.close();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return bitmap;
    }

    @Override
    protected void onProgressUpdate(Integer... values) {
        super.onProgressUpdate(values);
        progressBar2.setProgress(values[0]);
    }

    @Override
    protected void onPostExecute(Bitmap bitmap) {
        super.onPostExecute(bitmap);
        if (isCancelled()) {
            return;
        }
        progressBar.setVisibility(View.INVISIBLE);
        progressBar2.setVisibility(View.INVISIBLE);
        imageView.setImageBitmap(bitmap);
    }
}

//activity_main.xml:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="10dp"
    tools:context=".Main">

    <Button
        android:id="@+id/button"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Show the Image"
        android:layout_gravity="center"
        android:onClick="startload"/>

    <TextView
        android:id="@+id/tv"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:visibility="invisible"
        android:layout_gravity="center"
        android:text="已成功显示"
        android:textSize="40dp"/>

    <ImageView
        android:id="@+id/imageView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"/>

    <ProgressBar
        android:id="@+id/progressBar"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="100dp"
        android:visibility="invisible" />

    <TextView
        android:id="@+id/textView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:visibility="invisible"
        android:textSize="20dp"
        android:layout_marginTop="30dp"
        android:layout_gravity="center"
        android:text="" />

    <ProgressBar
        android:id="@+id/progressBar2"
        
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:visibility="invisible" />

</LinearLayout>

public void onPause(){
if (mtask ! = null || mtask.getStatus() == AsyncTask.Status.RUNNING) {
        mtask.cancel(true);
        //若AsyncTask对象存在且处于运行状态，便将此对象标记为
        //取消状态，然后在doInBackground()方法中利用isCancelled()
        //方法进行相应操作
}

---转
1.protected Bitmap doInBackground(String... params)传进来的是一个可变长的数组。<br><br>
2.String url = params[0];取出对应的URL<br><br>
3.URLConnection connection：定义网络连接对象<br><br>
4.InputStream is ：用于获取数据的输入流。<br><br>
5.connection = new URL(url).openConnection():获取网络连接对象。<br><br>
6. is = connection.getInputStream():获取输入流<br><br>
7.bitmap = BitmapFactory.decodeStream();将输入流解析成bitmap<br><br>
8.is.close();关闭输入流
9.bis.close()关闭输入流
<br><br>
通过这些方式就将url所对应的图片解析成了bitmap

AsyncTask<String,Void,Bitmap>三个参数分别为：url类型，进度值类型，返回值类型。
这里的例子暂时不设置进度值，url设置为String类型，又因为我们加载的是一张Bitmap，所以返回的参数类型设置为 Bitmap。
1. doInBackground(String...params)传进来的是一个可变长数组，也就是说，我们可以传进不止一个参数（通过execute()传进来），这些参数依次存在于这个数组中。现在只有一个参数，所以只要写个params[0]取出对应的URL即可。

回调方法的调用顺序

构建AsyncTask子类的回调方法

AsyncTask子类的参数

1. 必须在ui线程中创建asynctask实例，并调用execute方法

2. 重写的方法是系统自动调用 的，也就是我们只能重写，不能选择何时调用
   

3. 每个asynctask只能执行一次，多次调用会引发运行时异常

4. 只有doinbackground才是运行在其他线程（非主线程）更新ui是在主线程
   

asynasynctask异步操作的示例

继承asynctask<string, void ,bitmap>

string 启动任务时输入的参数类型

void后台执行任务时返回的  进度值类型

bitmap 后台执行任务后返回  结果的类型

1. 子类调用execute方法，以URL为传进去的参数

2. 调用onpreexecute，进行初始化操作，比如将进度条可见

3. 调用doinbackground方法进行真正的异步操作处理，例如耗时操作，返回一个类型给onpostexecute方法

4. onpostexecute方法（运行在主线程，可进行ui操作，显示图片）
   

asynctask <params,progress,result> 

params:启动任务时输入的参数类型

progress:后台执行任务时返回的  进度值类型

result ：后台执行任务后返回  结果的类型

asynctask子类必须回调的方法及顺序：

2、doinbackground：必须重写，在里面执行了publishprogress方法，系统才回调3、onprogressupdate方法

1、onpreexecute：后台耗时任务操作前被调用，用于初始化操作

4、onpostexecute：当doinbackground完成后返回值，系统自动调用onpostexecute，接收值