Android 学习笔记之AndBase框架学习(四) 使用封装好的函数实现单，多线程任务

PS：Force Is Meaningless Without Skill

 

学习内容：

1.使用AndBase实现单线程任务...

2.使用AndBase实现多线程任务...

 

  AndBase内部封装了多种方法，我们可以使用这些方法构建单线程任务和多线程任务..一般线程任务用于执行耗时的操作...比如说下载什么安装包，文件等数据量较大的东西，我们是必须要开启一个异步线程或者是同步线程来执行操作...如果任务过多，那么我们就可以使用任务请求队列或者是线程池来处理多个任务...这样可以节省很多的时间...

  涉及到的类为com.ab.task包中大部分类..AbThread.java , AbTaskPool.java , AbTaskQueue.java , AbTask.java是任务调度类的实现..功能不太相同..不过总体处理任务的添加和处理模式基本都是相同的...

  首先需要建立处理任务的线程对象...无论是异步线程，同步线程，还是线程池都需要先建立对象..然后对任务进行添加...添加完之后，线程会对任务进行处理..最后把结果返回..任务的建立需要使用到AbTaskItem...item会绑定上一个position，listener,result..这三个变量表示当前任务的任务号，任务执行监听，以及执行后的结果..

  任务的listener需要绑定..通过AbTaskListener来进行绑定..这个监听包含两个方法..一个是执行过程中的方法..也就是任务需要做的事情..get()函数...一个是任务执行完毕后需要执行的操作...update()函数..

1.使用AndBase实现单线程任务...

  实现单线程任务非常的简单..实现由两种方式..一个是使用Handler Message机制来处理当前的任务，一个是使用AsyncTask来处理当前的任务...

  先说说Handler Message线程执行任务...

public void ThreadClick(View v){
        //单个线程执行任务...
        
        //创建一个线程对象..
        AbThread thread=new AbThread();
                
        //定义一个任务对象...
        final AbTaskItem item=new AbTaskItem();
        item.listener=new AbTaskListener(){
                    
            @Override
            public void update(){
                showToast("执行完成");
            }
                    
            @Override
            public void get(){
                                //耗时的操作...
                showToastInThread("开始执行");//这步必须使用一个线程来显示Toast框..因为当前线程已经去处理当前任务了..
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            };
        };
                
        thread.execute(item); //向处理线程中加入任务..
    }

  这个过程和我上面说的基本是一样的...首先建立一个任务执行对象...然后定义一个任务请求..为这个请求设置相关监听..实现内部的方法...当任务处理完成后..调用handler Message机制来完成对结果的发送...最后通过update()中的方法来告知任务已经处理完毕...

 再来看看异步线程执行单个任务...

 异步线程执行任务其实效果是一样的...异步线程继承与AsyncTask..有基础的都应该很清楚AsyncTask，后台线程..可以通过在后台执行任务来更新UI界面...

public void TaskClick(View v){
    
        //异步任务执行..
        AbTask task=new AbTask();
        
        //定义任务对象...
        
        AbTaskItem item=new AbTaskItem();
        item.listener=new AbTaskListener(){
            
            @Override
            public void get(){
                showToastInThread("开始执行");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            
            @Override
            public void update(){
                showToast("执行完成");
            }
            
        };
        task.execute(item);
    }

  模式基本都是一样的，不过一个是使用了继承AsyncTask实现了异步的加载..一个使用了Handler Message...

2.使用AndBase实现多线程任务...

  多线程任务其实也非常的简单...一个是使用了任务队列的方式先对任务进行保存，将任务队列提交给线程池，由线程池来进行相关的处理...另一个则是直接将任务添加到线程池内部..由线程池对任务进行相关的处理...

  采用任务队列的方式将任务添加到队列当中，然后将当前队列提交给线程池..由线程池来完成这些任务的处理..

    public void QueueClick(View v){
        //线程任务队列...
        AbTaskQueue queue=new AbTaskQueue();
        //定义一个任务..
        AbTaskItem item=new AbTaskItem();
        AbTaskItem item_1=new AbTaskItem();
        item.listener=new AbTaskListener(){
            
            @Override
            public void update(){
                showToast("执行完成");
            }
            
            @Override
            public void get(){
                showToastInThread("任务执行1");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            
        };
        
                
        item_1.listener=new AbTaskListener(){
            
            @Override
            public void update(){
                showToast("执行完成");
            }
            
            @Override
            public void get(){
                showToastInThread("任务执行2");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            
        };
        queue.execute(item);
        queue.execute(item_1);
        
        //强制停止..
//        queue.quit();
        
        //强制停止前面的请求..
//        queue.execute(item_1, true);
        
    }

  采用直接将任务提交给线程池，然后由线程池来对任务进行处理...感觉二者的模式区别不是非常的大...

public void PoolClick(View v){
        //任务线程池...
        AbTaskPool pool=AbTaskPool.getInstance();
        
        AbTaskItem item=new AbTaskItem();
        AbTaskItem item_1=new AbTaskItem();
        
        item.listener=new AbTaskListener(){
            
            @Override
            public void get(){
                showToastInThread("开始执行1");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }

            @Override
            public void update(){
                removeProgressDialog();
                showToast("执行完成1");
            }
        
        };
        
        item_1.listener=new AbTaskListener(){
            
            @Override
            public void get(){
                showToastInThread("开始执行2");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            
            @Override
            public void update(){
                removeProgressDialog();
                showToast("任务完成2");
            }
        };
        pool.execute(item);
        pool.execute(item_1);
    }