AsyncTask 很好

一、基础篇 1 ）UI 线程概念 Android 为单线程模型。当一个程序第一次启动时，Android会自动创建一个对应的主线程（Main Thread）。它负责把事件分派到相应的控件，用于用户与Android控件进行交互。所以通常又被叫做 UI 线程。在开发Android应用时必须遵守单线程模型的原则： Android UI 操作并不是线程安全的并且这些操作必须在UI 线程中执行。简单表述为：1、不要阻塞UI线程；2、只能在主线程操作UI。详见Android帮助文档Dev Guide,左侧栏Processes and Threads。 2 ）UI 线程示例 2.1）UI线程阻塞不考虑Android单线程模型，将所有任务都在该线程中执行，尤其是某些耗时操作，会使得整个用户界面被阻塞。从用户角度来看，就是按键或触屏后响应很慢甚至毫无响应。而且当应用程序阻塞的时间过长时，Android还会向用户提示一个无响应的对话框（不截了==）。 2.2）非主线程更新UI 1、LogCat会报如下的错误消息：

Uncaught handler: thread Thread-9 exiting due to uncaught exception。

android.view.ViewRoot$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.

2、Android会向用户提示一个强行关闭的对话框（又不截了==）。 2.3）非主线程更新UI 三种方式：①Handler；②View.post(Runnable)；③Activity.runOnUiThread(Runnable)。 2.4）好了，开始动手测试吧^^

                    publicclassUIThreadActivityextendsBaseActivity{
            
            /**标签*/
            privateTextViewtextView;
            
            /**Runnable*/
            privateRunnablerunnable=newRunnable(){
            
            @Override
            publicvoidrun(){
            logThreadId();//打印当前线程ID
            textView.setText(tag+",I'mJoin!");//执行UI操作
            }
            };
            
            @Override
            protectedvoidonCreate(BundlesavedInstanceState){
            super.onCreate(savedInstanceState);
            setContentView(R.layout.ui_thread);
            tag="UIThreadActivity";
            textView=(TextView)findViewById(R.id.textView);
            }
            
            /**1.1UI线程阻塞*/
            publicvoidblockUi(Viewv){
            tag="blockUi";
            logThreadId();//打印当前线程ID
            
            /*读取网页内容并显示*/
            textView.setText("开始读取网页！");//该步可能未显示，为什么？
            StringBufferdocument=loadHtml("http://www.google.com");//耗时操作：读取网页源码
            textView.setText(null==document?"读取失败！":document.toString());//显示网页源码
            /**
            *1.观察按钮呈按下状态持续时间<br>
            *2.尝试在按钮呈按下状态时，进行按键和触屏操作<br>
            */
            }
            
            /**1.2非主线程更新UI*/
            publicvoidupdateUi(Viewv){
            tag="updateUi";
            newThread(runnable).start();
            }
            
            /**2.1方法1：Handler*/
            publicvoidmethodOne(Viewv){
            tag="methodOne";
            //Can'tcreatehandlerinsidethreadthathasnotcalled
            //Looper.prepare();
            finalHandlerhandler=newHandler();
            newThread(newRunnable(){
            @Override
            publicvoidrun(){
            logThreadId();//打印当前线程ID
            handler.post(runnable);
            //handler.postDelayed(runnable,1000);
            }
            }).start();
            }
            
            /**2.2方法2:View.post(Runnable)*/
            publicvoidmethodTwo(Viewv){
            tag="methodTwo";
            newThread(newRunnable(){
            @Override
            publicvoidrun(){
            logThreadId();//打印当前线程ID
            textView.post(runnable);
            //textView.postDelayed(runnable,1000);
            }
            }).start();
            }
            
            /**2.3方法3：Activity.runOnUiThread(Runnable)*/
            publicvoidmethodThree(Viewv){
            tag="methodThree";
            newThread(newRunnable(){
            @Override
            publicvoidrun(){
            logThreadId();//打印当前线程ID
            runOnUiThread(runnable);
            }
            }).start();
            }
            
            /**
            *读取网页源码
            */
            privateStringBufferloadHtml(StringurlStr){
            try{
            StringBufferdoc=newStringBuffer();
            URLurl=newURL(urlStr);
            URLConnectionconn=url.openConnection();
            BufferedReaderreader=newBufferedReader(newInputStreamReader(
            conn.getInputStream()));
            Stringline=null;
            while((line=reader.readLine())!=null)
            doc.append(line);
            reader.close();
            returndoc;
            }catch(IOExceptione){
            e.printStackTrace();
            }
            returnnull;
            }
            
            }

亲，记得看Log日志出的线程id哦。（卖下萌，不介意吧？） 二、提高篇 1 ）Android 消息处理机制 熟悉Android开发的可能知道其应用程序都是由消息驱动的。参考了Windows的消息循环机制，Android系统通过Handler、Thread、Looper以及MessageQueue实现了这种消息机制。相关的类都被定义在了package android.os。推荐这篇博客咯—— 解析Android消息处理机制。（这个，那个，还建模==） 2 ）实用的消息处理方式 2.1）Thread实现消息循环

                    /**1.1Thread实现消息循环*/
            publicvoidmethodOne(Viewv){
            tag="methodOne";
            
            //创建一个LooperThread对象，实现了消息循环
            LooperThreadthread=newLooperThread();
            //必须启动这个线程
            thread.start();
            
            //创建一个消息对象并设置信息
            Messagemsg=newMessage();
            Bundlebundle=newBundle();
            bundle.putString("key","1.1Thread实现消息循环");
            msg.setData(bundle);
            //发送消息对象
            thread.mHandler.sendMessage(msg);
            }
            
            /**实现消息循环的线程（在Android索引文档android.os.Looper的概述里有介绍）*/
            privateclassLooperThreadextendsThread{
            publicHandlermHandler;
            
            publicvoidrun(){
            Looper.prepare();
            
            mHandler=newHandler(){
            publicvoidhandleMessage(Messagemsg){
            //processincomingmessageshere
            logThreadId();//打印当前线程ID
            Log.e(tag,msg.getData().getString("key"));
            }
            };
            
            Looper.loop();
            }
            }

如果不使用Looper.prepare()及loop()的话，就不能创建Handler将消息处理加入到Looper中。LogCat会报“Can't create handler inside thread that has not called Looper.prepare();”的错误信息。 2.2）Handler与Looper相关联如果构造一个无参的Handler对象，它将自动与当前运行线程相关联。可以注意Handler相关例子中打印出的当前线程ID信息。而与Looper相关联，需要创建一个带参数的Handler对象。注意：此时线程类应该是一个HandlerThread类，一个Looper类的Thread类。

                    /**1.2Handler与Looper相关联*/
            publicvoidmethodTwo(Viewv){
            tag="methodTwo";
            
            //生成一个HandlerThread对象，使用Looper来处理消息队列
            HandlerThreadthread=newHandlerThread("MyThread");
            //必须启动这个线程
            thread.start();
            //将一个线程绑定到Handler对象上，则该Handler对象就可以处理线程的消息队列
            MyHandlermyhandler=newMyHandler(thread.getLooper());
            //从Handler中获取消息对象
            Messagemsg=myhandler.obtainMessage();
            //设置消息对象信息
            Bundlebundle=newBundle();
            bundle.putString("key","1.2Handler与Looper相关联");
            msg.setData(bundle);
            //将消息对象发送给目标对象Handler
            msg.sendToTarget();
            }
            
            /**重写Handler的消息处理方法*/
            privateclassMyHandlerextendsHandler{
            
            //带有参数的构造函数
            publicMyHandler(Looperlooper){
            super(looper);
            }
            
            @Override
            publicvoidhandleMessage(Messagemsg){
            //processincomingmessageshere
            logThreadId();//打印当前线程ID
            Log.e(tag,msg.getData().getString("key"));
            }
            }

所以，Wifi的HandlerThread，WifiHandler可以这样实例化（推荐博客有述）：

                    HandlerThreadwifiThread=newHandlerThread("WifiService");
            wifiThread.start();
            mWifiHandler=newWifiHandler(wifiThread.getLooper());

2.3）Hanlder与Thread实现异步在新线程中执行耗时操作，结束后通过Handler来更新UI。

                    /**1.3Hanlder与Thread实现异步*/
            publicvoidmethodThree(Viewv){
            tag="methodThree";
            /*初始化进度条*/
            progressBar.setProgress(0);
            progressBar.setVisibility(View.VISIBLE);
            //新线程执行某操作
            newProgressThread(0).start();
            }
            
            /**更新UI*/
            privateHandlermyHandler=newHandler(){
            @Override
            publicvoidhandleMessage(Messagemsg){
            progressBar.setProgress(msg.getData().getInt("key"));
            }
            };
            
            /**新线程任务*/
            privateclassProgressThreadextendsThread{
            
            privateintprogress;
            
            publicProgressThread(intprogress){
            this.progress=progress;
            }
            
            @Override
            publicvoidrun(){
            
            try{
            while(progress<=100){
            
            progress+=5;//进度+5
            
            //doSomething();//执行耗时操作
            Thread.sleep(100);
            
            //从Handler中获取消息对象
            Messagemsg=myHandler.obtainMessage();
            //设置消息对象信息
            Bundleb=newBundle();
            //向Handler发送消息，更新UI
            b.putInt("key",progress);
            msg.setData(b);
            myHandler.sendMessage(msg);
            }
            }catch(InterruptedExceptione){
            e.printStackTrace();
            }
            }
            }

3 ）Android 异步线程——AsyncTask 当任务需要复杂操作并频繁更新UI时，上述的非主线程访问UI方法会使得代码结构复杂和难以理解。所以Android1.5提供了一个工具类AsyncTask，用以创建与用户界面交互的长时间任务。也在被定义在了package android.os。 AsyncTask定义了3种泛型类型：Params,ProgressandResult；4个执行步骤：onPreExecute,doInBackground,onProgressUpdateandonPostExecute。 3.1）泛型类型 1) Params，发送给后台任务处理的参数类型 2) Progress，后台任务过程中发布的进度单位 3) Result，后台任务结束后返回的结果类型
想了解泛型类型的话，可参见我的 Java泛型应用浅析一文^^。 3.2）执行步骤 1) onPreExecute()，该方法将在执行实际的后台操作前被UI thread调用。可以在该方法中做一些准备工作，如在界面上显示一个进度条。 2) doInBackground(Params...)，将在onPreExecute方法执行后马上执行，该方法运行在后台线程中。这里将主要负责执行那些很耗时的后台计算工作。可以调用 publishProgress方法来更新实时的任务进度。该方法是抽象方法，子类必须实现。 3) onProgressUpdate(Progress...)，在publishProgress方法被调用后，UI thread将调用这个方法从而在界面上展示任务的进展情况，例如通过一个进度条进行展示。 4) onPostExecute(Result)，在doInBackground执行完成后，onPostExecute方法将被UI thread调用，后台的计算结果将通过该方法传递到UI thread。 onPostExecute的参数为doInBackground的返回值，类型由第三个泛型类型所指定。例子里仅是String，也可以是你自己的实体类、接口什么的。 3.3）使用准则 1) Task的实例必须在UI thread中创建 2) execute方法必须在UI thread中调用 3) 不要手动的调用onPreExecute(), onPostExecute(Result)， doInBackground(Params...), onProgressUpdate(Progress...)这几个方法 4) 该task只能被执行一次，否则多次调用时将会出现异常 3.4）任务取消一个任务在任何时候都能够通过调用cancel(boolean)而取消。调用这个方法，将使得随后调用的isCancelled()返回true。并且在执行完doInBackground(Object[])后，会去调用onCancelled(Object)而不再是onPostExecute(Object)方法。为了确保任务能够尽快的被取消，可以在doInBackground(Object[])内定期校验isCancelled()的返回值（例如在循环判断中）。 3.5）样例程序

                    /**2Android异步线程——AsyncTask*/
            publicvoidmethodFour(Viewv){
            tag="methodFour";
            newLoadHtmlTask(this).execute("http://www.baidu.com");//执行读取网页任务
            //newLoadHtmlTask(this).execute("http://www.google.com");//获取不到内容长度
            //newLoadHtmlTask(this).execute("http://www.sina.com");//获取大量网页数据
            }
            
            /**读取网页任务*/
            privateclassLoadHtmlTaskextendsAsyncTask<String,Integer,String>{
            
            privateContextmContext;
            privateProgressDialogdialog;//进度框
            
            publicLoadHtmlTask(Contextcontext){
            this.mContext=context;
            initDialog();//初始化进度对话框
            }
            
            /**初始化进度对话框*/
            privatevoidinitDialog(){
            dialog=newProgressDialog(mContext);
            dialog.setMax(100);//设置最大进度值
            dialog.setTitle("Loading...");//设置标题
            dialog.setCancelable(false);//设为返回键不可取消
            dialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);//设为进度条样式
            //增加取消按钮及其事件
            dialog.setButton("取消",newDialogInterface.OnClickListener(){
            publicvoidonClick(DialogInterfacedialog,inti){
            dialog.dismiss();//取消显示
            cancel(true);//取消并中断任务
            }
            });
            }
            
            /**doInBackground之前，在主线程执行*/
            @Override
            protectedvoidonPreExecute(){
            logThreadId("onPreExecute()");//打印当前线程ID
            dialog.show();//显示进度对话框
            }
            
            /**onPreExecute()之后，在后台线程执行*/
            @Override
            protectedStringdoInBackground(String...params){
            logThreadId("doInBackground");//打印当前线程ID
            //未传入参数直接返回
            if(null==params||params.length<=0){
            return"请确认输入了网址参数！";
            }
            try{
            //创建HttpGet对象，params[0]为url
            HttpGethttpGet=newHttpGet(params[0]);
            
            //发送HttpGet请求，并返回HttpResponse对象
            HttpResponseresponse=newDefaultHttpClient()
            .execute(httpGet);
            //判断响应状态，200表示成功响应
            if(response.getStatusLine().getStatusCode()==200){
            HttpEntityentity=response.getEntity();//获取返回结果
            
            longlength=entity.getContentLength();//获取内容长度（google获取不到）
            booleangetLen=length>0?true:false;//判断是否获取了内容长度
            
            InputStreamis=entity.getContent();//获取响应内容
            if(is!=null){
            ByteArrayOutputStreambaos=newByteArrayOutputStream();
            byte[]buf=newbyte[128];
            intch=-1;
            longcount=0;
            while((ch=is.read(buf))!=-1&&!isCancelled()){//同时还未取消
            baos.write(buf,0,ch);
            count+=ch;
            if(getLen){//获取了内容长度时
            //调用publishProgress()更新进度
            publishProgress((int)((count/(float)length)*100));
            }
            }
            is.close();
            baos.close();
            returnnewString(baos.toByteArray());//返回结果
            }
            return"无返回内容！";
            }else{
            return"服务器未响应或失败！";
            }
            }catch(Exceptione){
            e.printStackTrace();
            }
            return"程序异常啦！";
            }
            
            /**调用了publishProgress()，在主线程执行*/
            @Override
            protectedvoidonProgressUpdate(Integer...values){
            //logThreadId("onProgressUpdate");//打印当前线程ID
            dialog.setProgress(values[0]);
            }
            
            /**未调用了cancel()，doInBackground()结束后，在主线程执行*/
            @Override
            protectedvoidonPostExecute(Stringresult){
            logThreadId("onPostExecute(result)");//打印当前线程ID
            dialog.dismiss();//取消显示
            showMsg(result);//显示结果
            }
            
            /**调用了cancel()，doInBackground()结束后，在主线程执行*/
            @Override
            protectedvoidonCancelled(){
            logThreadId("onCancelled");//打印当前线程ID
            showMsg("用户取消了该任务！");
            }
            
            /**提示框显示消息*/
            privatevoidshowMsg(Stringmessage){
            
            //message内容过多时，提示框显示会延迟，例如sina
            newAlertDialog.Builder(mContext)
            .setTitle("消息")
            .setMessage(message)
            .setNegativeButton("关闭",
            newDialogInterface.OnClickListener(){
            @Override
            publicvoidonClick(DialogInterfacedialog,
            intwhich){
            dialog.dismiss();
            }
            }).show();
            }
            
            }

三、扩展篇 1）Service中的Toast Service中不能直接使用Toast提示信息，推荐如下方式：

                    privateHandlerhandler;//Handler
            
            Override
            publicvoidonCreate(){
            Log.i("onCreate","==onCreate==");
            super.onCreate();
            
            handler=newHandler(Looper.getMainLooper());//使用应用的主消息循环
            }
            
            /**
            *Toast提示（service中toast不能直接显示）
            */
            privatevoidshowToast(finalintresId,finalObject...formatArgs){
            handler.post(newRunnable(){
            publicvoidrun(){
            Toast.makeText(getApplicationContext(),
            getString(resId,formatArgs),Toast.LENGTH_SHORT)
            .show();
            }
            });
            //以下方式只能显示一次
            //Looper.prepare();
            //Toast.makeText(this,resId,Toast.LENGTH_SHORT).show();
            //Looper.loop();
            }

2）Java线程池一些简单常用的线程池，只需使用Executors类里面提供了一些静态工厂，如下： 1）newSingleThreadExecutor：创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。 2）newFixedThreadPool：创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。 3）newCachedThreadPool：创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。 4）newScheduledThreadPool：创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。 5）newSingleThreadExecutor：创建一个单线程的线程池。此线程池支持定时以及周期性执行任务的需求。或者使用ThreadPoolExecutor，更加定制化地构造线程池。它们都被定义在package java.util.concurrent。线程池技术是为了减少频繁创建和销毁线程的系统开销，适用情况有：1）单个任务时间很短、处理请求巨大；2）有突发性大量任务请求；3）需要迅速响应的性能要求等。

                    publicclassTestPoolimplementsRunnable{
            
            privatestaticfinalStringTAG="TestPool";//标记
            
            privateExecutorServiceservice;//线程池
            
            publicTestPool(){
            //service=Executors.newSingleThreadExecutor();//创建一个单任务线程池
            service=Executors.newFixedThreadPool(3);//创建最多同时运行3个任务线程池
            }
            
            /**增加一个线程任务*/
            publicvoidaddTask(){
            service.execute(this);
            }
            
            /**线程任务*/
            @Override
            publicvoidrun(){
            log(1);//显示日志
            try{
            Thread.sleep(5*1000);
            }catch(InterruptedExceptione){
            e.printStackTrace();
            }
            log(2);//显示日志
            }
            
            /**显示日志*/
            privatevoidlog(intwhich){
            Stringresult=1==which?"，任务开始！":"，任务结束！";
            Log.e(TAG,"线程："+String.valueOf(Thread.currentThread().getId())
            +result);
            }
            
            }

3）Java线程同步多线程并发访问同一数据时，就会有同步的需求。Java内在的同步机制包含：同步块（或方法）和 volatile 变量。同步块（或方法）通过synchronized关键字声明，而volatile可被看做是轻量级的synchronized。 Java为每个object分配了一个monitor，相关方法如下： 1）obj.wait()方法将使本线程挂起，并释放obj对象的monitor。只有其他线程调用obj对象的notify()或notifyAll()时，才可以被唤醒。 2）obj.notifyAll()方法唤醒所有该obj对象相关的沉睡线程，然后被唤醒的众多线程开始竞争obj对象的monitor占有权，最终得到的那个线程会继续执行下去，但其他线程还将继续等待。 3）obj.notify()方法是随机唤醒一个沉睡线程。 4）wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用。没多线程不需要同步，有多线程不一定需要同步。

                    publicclassTestSync{
            
            privateProductproduct;
            privateConsumerConsumerA,ConsumerB;
            
            publicTestSync(){
            product=newProduct();
            ConsumerA=newConsumer("小怪兽A",product);
            ConsumerB=newConsumer("小怪兽B",product);
            }
            
            publicvoidproduce(){
            synchronized(product){
            
            Log.e("TestSync","\\(^o^)/，投掷一个果冻！");
            product.plus();//增加一个产品
            
            /*优先使用notifyAll()，更容易让jvm找到最适合被唤醒的线程*/
            
            //product.notify();//唤醒一个线程
            product.notifyAll();//唤醒所有线程
            }
            }
            
            publicvoidstart(){
            ConsumerA.start();
            ConsumerB.start();
            }
            
            publicvoidstop(){
            ConsumerA.stopEating();
            ConsumerB.stopEating();
            
            synchronized(product){
            product.notifyAll();//唤醒所有线程
            }
            }
            
            }
            
            /**产品*/
            classProduct{
            
            privateintcount=0;//产品数量
            
            publicProduct(){
            }
            
            /**是否无产品*/
            publicbooleanisNull(){
            returncount<=0?true:false;
            }
            
            /**增加产品*/
            publicvoidplus(){
            count++;
            }
            
            /**减少产品*/
            publicvoidminus(){
            count--;
            }
            
            }
            
            /**消费者*/
            classConsumerextendsThread{
            
            privateStringname;//消费者
            privateProductproduct;//产品
            privateintcount=0;//数量
            
            privatebooleanwaitEating=true;//标记
            
            publicConsumer(Stringname,Productproduct){
            this.name=name;
            this.product=product;
            }
            
            @Override
            publicvoidrun(){
            while(waitEating){
            
            synchronized(product){
            
            while(product.isNull()&&waitEating){
            try{
            Log.e(name,"（¯��¯），等待果冻中...");
            product.wait();
            }catch(InterruptedExceptione){
            e.printStackTrace();
            }
            }
            
            if(waitEating){
            Log.e(name,"~\\(�R��Q)/~，抢到了果冻！");
            product.minus();
            count++;
            }
            }
            }
            Log.e(name,"(～o～)~zZ，吃不下了。计："+count);
            }
            
            publicvoidstopEating(){
            waitEating=false;
            }
            
            }

更多相关文章

随机推荐