Android_读书笔记_1

首页 > 代码库 > Android_读书笔记_1

2024-07-06 20:22:33 228人阅读

线程及异步操作

大体上阐述了异步处理的重要性，以及什么时候应该用异步处理等等巴拉巴拉......

重点：

1：

AsyncTask类的介绍及例子......

通过继承AsyncTask类并实现其定义的事件方法，管理后台操作。

很方便的是AsyncTask类已经为异步操作创建好了一个简单的接口，我们只需实现这个接口就可以很快捷的实现异步操作。

并且在最新的几个SDK中，它能够通过若干个物理内核和一个内部线程池来同时管理多个任务。

包括：

onPreExecute()方法在后台操作开始前运行在UI线程上

doInBackground()方法运行在后台并处理后台操作

从该方法中调用publishProgress()方法能够周期性的通知UI线程有关后台操作的进度

当其( doInBackground()方法 )调用publishProgress()方法时

onProgressUpdate()方法就会在UI线程中运行，通过不同的参数来传递不同的信息

一旦后台操作完成，就会自动在UI线程中调用onPostExrcute()方法,AsyncTask类能够以后台的方式处理操作，不会阻塞UI线程。

启动方法有2种：

1.实例化所创建的AsyncTask子类，调用execute()方法，启动异步操作。

2.实例化所创建的AsyncTask子类，调用executeOnExecutor( AsyncTask.THREAD_POOL_EXECUTOR, Integer... )方法，启动异步操作。

区别：API L11+的设备中，前者( execute() ) 任务可以”平行“的被执行，在多核处理器设备上，该方法能有效地提高任务的完成速度，并隐性的提高应用程序的效率和流畅性。后者( executeOnExecutor( AsyncTask.THREAD_POOL_EXECUTOR, Integer... ) )则保证了同时执行若干个任务，每个任务相互独立。

注:如果不想同时执行多个任务，可以调用executeOnExecutor( AsyncTask.SERIAL_EXECUTOR )方法，但是只有再API L14+中才能确认是线性的。

实例：

 1 package com.example.asynctask;
 2 
 3 import android.os.AsyncTask;
 4 import android.os.Bundle;
 5 import android.os.SystemClock;
 6 import android.app.Activity;
 7 import android.widget.TextView;
 8 
 9 public class SimpleAsyncTask extends Activity {
10 
11     @Override
12     protected void onCreate(Bundle savedInstanceState) {
13         super.onCreate(savedInstanceState);
14         setContentView(R.layout.activity_main);
15 
16         CountingTask tsk = new CountingTask();
17         tsk.execute();
18 
19     }
20 
21     private class CountingTask extends AsyncTask<Void, Integer, Integer> {
22 
23         CountingTask() {
24         }
25 
26         @Override
27         protected Integer doInBackground(Void... unused) {
28 
29             int i = 0;
30             while (i < 100) {
31 
32                 SystemClock.sleep(100);
33                 i++;
34 
35                 if (i % 5 == 0) {
36 
37                     // 每5%进度更新一次UI
38                     publishProgress(i);
39                 }
40             }
41 
42             return i;
43         }
44 
45         protected void onProgressUpdate(Integer... progress) {
46 
47             TextView tv = (TextView) findViewById(R.id.text);
48             tv.setText(progress[0] + " % Complete! ");
49         }
50 
51         protected void onPostExecute(Integer result) {
52 
53             TextView tv = (TextView) findViewById(R.id.text);
54             tv.setText("Count Complete ! Count to " + result.toString());
55         }
56     }
57 }

execute()实现

 1 package com.example.asynctask;
 2 
 3 import android.app.Activity;
 4 import android.os.AsyncTask;
 5 import android.os.Bundle;
 6 import android.os.SystemClock;
 7 import android.widget.TextView;
 8 
 9 public class SimpleMultiCoreAsyncTask extends Activity {
10 
11     @Override
12     protected void onCreate(Bundle savedInstanceState) {
13         super.onCreate(savedInstanceState);
14         setContentView(R.layout.activity_simple_multi_core_async_task);
15         
16         CountingTask tsk = new CountingTask();
17         tsk.executeOnExecutor( AsyncTask.THREAD_POOL_EXECUTOR, R.id.tv_AsyncTask_1 );
18         
19         startParallelTask( R.id.tv_AsyncTask_2 );
20         startParallelTask( R.id.tv_AsyncTask_3 );
21         startParallelTask( R.id.tv_AsyncTask_4 );
22         startParallelTask( R.id.tv_AsyncTask_5 );
23         startParallelTask( R.id.tv_AsyncTask_6 );
24         
25         //注意,貌似只能第一时间同时启动前5个,完成后才会启动第6个......
26     }
27 
28     private void startParallelTask( int _id ) {
29         
30         CountingTask tsk = new CountingTask();
31         tsk.executeOnExecutor( AsyncTask.THREAD_POOL_EXECUTOR, _id );
32     }
33     
34     private class CountingTask extends AsyncTask<Integer, Integer, Integer> {
35 
36         private int _counterID;
37         
38         CountingTask() {
39         }
40 
41         @Override
42         protected Integer doInBackground(Integer... _id) {
43 
44             _counterID = _id[ 0 ];
45             int i = 0;
46             
47             while (i < 100) {
48 
49                 SystemClock.sleep(100);
50                 i++;
51 
52                 if (i % 5 == 0) {
53 
54                     // 每5%进度更新一次UI
55                     publishProgress(i);
56                 }
57             }
58 
59             return i;
60         }
61 
62         protected void onProgressUpdate(Integer... progress) {
63 
64             TextView tv = (TextView) findViewById( _counterID );
65             tv.setText(progress[0] + " % Complete! ");
66         }
67 
68         protected void onPostExecute(Integer result) {
69 
70             TextView tv = (TextView) findViewById( _counterID );
71             tv.setText("Count Complete ! Count to " + result.toString());
72         }
73     }
74 }

executeOnExecute()实现

------------------------------------------------我是分割线--------------------------------------------------------------

2:Thread类

比起上面的( AsyncTask ) ，其( Thread )类导入已有的代码更为简便直接

对于一个拥有独立线程的Activity类能够管理线程的生命周期,一般就会包括一个Handler类型的变量,Thread类被实例化启动时，Handler的post()方法就会被用于与主UI线程的通信，当然也可以使用Activity类中的runOnThread()方法或是View类中的post()和postDelayed()方法来与主UI线程通信。

实例：

 1 package com.example.asynctask;
 2 
 3 import android.os.Bundle;
 4 import android.os.SystemClock;
 5 import android.app.Activity;
 6 import android.view.Menu;
 7 import android.widget.TextView;
 8 
 9 public class SimpleThread extends Activity {
10 
11     @Override
12     protected void onCreate(Bundle savedInstanceState) {
13         super.onCreate(savedInstanceState);
14         setContentView(R.layout.activity_simple_thread);
15         
16         final TextView tv_thread = ( TextView ) findViewById( R.id.tv_thread );
17         
18         new Thread( new Runnable() {
19             
20             @Override
21             public void run() {
22                 
23                 int i = 0;
24                 
25                 while ( i < 100 ) {
26                     
27                     SystemClock.sleep( 250 );
28                     i++;
29                     
30                     final int curCount = i;
31                     
32                     if( curCount % 5 == 0 ) {
33                         
34                         tv_thread.post( new Runnable() {
35                             
36                             @Override
37                             public void run() {
38                                 
39                                 tv_thread.setText( curCount + " % Complete! " );
40                             }
41                         });
42                     }
43                 }
44                 
45                 tv_thread.post( new Runnable() {
46                     
47                     @Override
48                     public void run() {
49                         
50                         tv_thread.setText( "Count Complete!" );
51                     }
52                 });
53             }
54         }).start();
55     }
56 }

Thread()实现

声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉：投诉/举报工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。

联系
我们

首页 > 代码库 > Android_读书笔记_1

Android_读书笔记_1

看完仍有疑问？有类似问题直接问程序猿