android线程及线程池-低调大师

android线程及线程池

2017-11-07 333

众所周知，在UI系统中进行一些耗时操作，都会导致卡顿现象，因为一次刷新在16ms，如果当次操作过了这个时间，那么用户就能感觉到明显的卡顿，甚至引起ANR 。
对于这种情况，一般都是再起一个线程，进行一些耗时的操作，通过继承Thread 或者实现Runnable接口，重写run方法，来实现创建新线程，进行耗时操作的需求.由于java的单继承关系，首推实现Runnable方法，这样不会太过臃肿。

private void runThread() {
        Thread t1 = new Thread(new MyRunnable(this), "郭富城");
        t1.start();
      //强调一点，调用run方法是真的调用方法，而调用start方法则会创建新线程去调用这个run方法。
    }

//实现runnable方法  至于继承Thread方法的代码 ，就不写了
    static class MyRunnable implements Runnable {
        private WeakReference<MainActivity> reference;

        MyRunnable(MainActivity activity) {
            reference = new WeakReference<MainActivity>(activity);
        }

        @Override
        public void run() {
            if (reference != null) {
                MainActivity activity = reference.get();
                if (activity != null) {
                    //子线程不能弹toast的 所以加了点东西
                    Looper.prepare();
                    Toast.makeText(activity, Thread.currentThread().getName() + " is Runing", Toast.LENGTH_SHORT).show();
                    Looper.loop();
                }
            }
        }
    }

另外，jdk1.5版本以后，就新加了个Callable接口，相较于Runnable接口，他可以定义返回值，并且可以抛出异常，需要实现的方法也从run方法变成了call方法。还有一点很有意思，他返回一个Future对象，通过这个对象，我们可以知道任务的进行程序，并且可以关闭这个任务。Thread是不支持这个接口的，所以如果要用Callable，就需要用上FutureTask.

@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;
}

public interface Future<V> {

    boolean cancel(boolean mayInterruptIfRunning);

    boolean isCancelled();

    boolean isDone();

    V get() throws InterruptedException, ExecutionException;

    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

简单的说，FutureTask是一种可以取消的异步任务，异步执行任务, 可以开始、取消以及查看任务是否完成, 如果任务没有执行完，get方法会导致线程阻塞, 一旦一个执行任务已经完成就不能再次开始和结束(除非执行时通过runAndReset()方法.另外，FutureTask也同样支持Runnable接口。

 private void runFutureTask() {
        //创建线程池 不用线程池 直接用future也可以的
        final ExecutorService exec = Executors.newFixedThreadPool(5);
        //创建futureTask任务
        final FutureTask<String> ft = new FutureTask<String>(new MyCallable());
        // 执行也可以 提交也可以 还有种invokeAll方法
        exec.execute(ft);
//        exec.submit(ft);
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    //get方法会自动阻塞当前线程  直到拿到结果
                    //所以不要放在主线程去get 不然就卡住了 虽然我试过卡个15秒也没事
                    final String text = ft.get();
                    Looper.prepare();
                    Toast.makeText(FutureTaskActivity.this, text, Toast.LENGTH_SHORT).show();
                    Looper.loop();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (ExecutionException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        //用完线程池 记得关闭掉
        exec.shutdown();
    }

    static class MyCallable implements Callable<String> {

        @Override
        public String call() throws Exception {
            Thread.sleep(3000);
            return "代码让我快乐，代码让我秃顶";
        }
    }

线程是CPU调度的最小单元，对于线程的创建，销毁，调度，其实也是在耗费一定资源的，特别是某些情况下，你需要创建一堆线程进行一些简单的耗时操作时，这个资源的消耗量还是非常大的，所以就有线程池的需求了。

我们来总结一下优点吧。
1.重用线程池中的线程，避免频繁地创建和销毁线程带来的性能消耗；
2.有效控制线程的最大并发数量，防止线程过大导致抢占资源造成系统阻塞；
3.可以对线程进行一定地管理。

使用线程池相对于每次都new 线程，性能会好很多，并且可以统一管理，功能上也能有所改善，如果需要定时执行，定期执行，线程中断等。
减少内存开销。

ThreadPoolExecutor：
  ExecutorService是最初的线程池接口，ThreadPoolExecutor类是对线程池的具体实现，它通过构造方法来配置线程池的参数，我们来分析一下它常用的构造函数吧。

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), defaultHandler);
}

参数解释：

    corePoolSize，线程池中核心线程的数量，默认情况下，即使核心线程没有任务在执行它也存在的，我们固定一定数量的核心线程且它一直存活这样就避免了一般情况下CPU创建和销毁线程带来的开销。我们如果将ThreadPoolExecutor的allowCoreThreadTimeOut属性设置为true，那么闲置的核心线程就会有超时策略，这个时间由keepAliveTime来设定，即keepAliveTime时间内如果核心线程没有回应则该线程就会被终止。allowCoreThreadTimeOut默认为false，核心线程没有超时时间。
    maximumPoolSize，线程池中的最大线程数，当任务数量超过最大线程数时其它任务可能就会被阻塞。最大线程数=核心线程+非核心线程。非核心线程只有当核心线程不够用且线程池有空余时才会被创建，执行完任务后非核心线程会被销毁。
    keepAliveTime，非核心线程的超时时长，当执行时间超过这个时间时，非核心线程就会被回收。当allowCoreThreadTimeOut设置为true时，此属性也作用在核心线程上。
    unit，枚举时间单位，TimeUnit。
    workQueue，线程池中的任务队列，我们提交给线程池的runnable会被存储在这个对象上。

线程池的分配遵循这样的规则：

    当线程池中的核心线程数量未达到最大线程数时，启动一个核心线程去执行任务；
    如果线程池中的核心线程数量达到最大线程数时，那么任务会被插入到任务队列中排队等待执行；
    如果在上一步骤中任务队列已满但是线程池中线程数量未达到限定线程总数，那么启动一个非核心线程来处理任务；
    如果上一步骤中线程数量达到了限定线程总量，那么线程池则拒绝执行该任务，且ThreadPoolExecutor会调用RejectedtionHandler的rejectedExecution方法来通知调用者。

四种线程池都可以通过Executors提供：

newCachedThreadPool：创建一个可缓存线程池，他是一个不限容量的线程池，其中创建的所有的线程都是非核心线程，如果线程池长度超过处理需要，超时时间设置为60s，如果当前没有任务，会回收空闲线程，若无可回收，则新建线程。用于执行一些生存期很短的异步型任务

public static ExecutorService new CachedThreadPool(){
    return new ThreadPoolExecutor(
        0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS,
        new SynchronousQueue<Runnable>()
    );
}
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

newFixedThreadPool ：创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。池线程数固定，创建的线程会一直存在。它没有超时机制并且等待队列无限常，所以fixedThreadPool多数针对一些很稳定很固定的正规并发线程，多用于服务器。

public static ExecutorService newFixedThreadPool(int nThreads){
    return new ThreadPoolExecutor(
        nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,
        new LinkedBlockingQueue<Runnable>() 
        );
}
//创建线程池
ExecutorService mExecutor = Executors.newFixedThreadPool(5);//参数即核心线程数

newScheduledThreadPool 创建一个定长线程池，其实他将上面两种线程池的优点全部集结成一块，他有一定数量的核心线程，并且无限容量的非核心线程，区别在于非核心线程的超时时间设定为0秒，即一旦空闲，立马回收，支持定时及周期性任务执行。

public static ScheduledThreadPool newScheduledThreadPool(int corePoolSize){
    return new ScheduledThreadPoolExecutor(corePoolSize);
}
public ScheduledThreadPoolExecutor(int corePoolSize){
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
          new DelayedWorkQueue());
}
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(10);//核心线程数

newSingleThreadExecutor 创建一个单线程化的线程池，他只有一个核心线程，它也只会用唯一的工作线程来执行任务，可以让调用者忽略线程同步的问题。

public static ExecutorService newSingleThreadExecutor(){
    return new FinalizableDelegatedExecutorService(
        new ThreadPoolExecutor(
        1, 1, 0L, TimeUnit.MILLISECONDS, 
        new LinkedBlockingQueue<Runnable>()));
}
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

线程池一般用法

    shutDown()，关闭线程池，需要执行完已提交的任务；
    shutDownNow()，关闭线程池，并尝试结束已提交的任务；
    allowCoreThreadTimeOut(boolen)，允许核心线程闲置超时回收；
    execute()，提交任务无返回值；
    submit()，提交任务有返回值；

newCachedThreadPool缓存线程池，如果线程超出则灵活回收，如果不够则创建
newFixedThreadPool 定长线程池，可以设置最大线程数，超出的任务在队列中等候。
newScheduledThreadPool 也是定长线程池，支持定时及周期性任务。
newSingleThreadExecutor 单线程化的线程池，任务根据加入顺序在队列中慢慢等待执行。

除了以上这些，在Android中充当线程的角色还有AsyncTask、HandlerThread、IntentService。它们本质上都是由Handler+Thread来构成的。

AsyncTask，它封装了线程池和Handler，主要为我们在子线程中更新UI提供便利。
HandlerThread，它是个具有消息队列的线程，可以方便我们在子线程中处理不同的事务。
IntentService，我们可以将它看做为HandlerThread的升级版，它是服务，优先级更高。

参考
http://blog.csdn.net/weixin_36244867/article/details/72832632
http://blog.csdn.net/linchunquan/article/details/22382487
http://www.hchstudio.cn/2017/04/01/FutureTask%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90/
http://www.cnblogs.com/wenjiang/archive/2012/09/02/2668089.html

本文转自一点点征服博客园博客，原文链接：http://www.cnblogs.com/ldq2016/p/8059010.html ，如需转载请自行联系原作者

微信关注我们

原文链接：https://yq.aliyun.com/articles/566781

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

Android线程与线程池

引言在Android中，几乎完全采用了Java中的线程机制。线程是最小的调度单位，在很多情况下为了使APP更加流程地运行，我们不可能将很多事情都放在主线程上执行，这样会造成严重卡顿（ANR），那么这些事情应该交给子线程去做，但对于一个系统而言，创建、销毁、调度线程的过程是需要开销的，所以我们并不能无限量地开启线程，那么对线程的了解就变得尤为重要了。 Thread/Runnable/Callable 一般实现线程的方法有两种，一种是类继承Thread，一种是实现接口Runnable。这两种方式的优缺点如何呢？我们知道Java是单继承但可以调用多个接口，所以看起来Runnable更加好一些。继承Thread class MyThread extend Thread(){ @Override public void run() { super.run(); Log.i(Thread.currentThread().getId()); } } new MyThread().start(); 实现Runnable接口 class MyThread implements Runnable{ ...

2017-11-08

575

好几个月都没有更新过博客了，从今天开始，老罗将尝试对Android系统的UI实现作一个系统的分析，也算是落实之前所作出的承诺。提到Android系统的UI，我们最先接触到的便是系统在启动过程中所出现的画面了。Android系统在启动的过程中，最多可以出现三个画面，每一个画面都用来描述一个不同的启动阶段。本文将详细分析这三个开机画面的显示过程，以便可以开启我们对Android系统UI实现的分析之路。第一个开机画面是在内核启动的过程中出现的，它是一个静态的画面。第二个开机画面是在init进程启动的过程中出现的，它也是一个静态的画面。第三个开机画面是在系统服务启动的过程中出现的，它是一个动态的画面。无论是哪一个画面，它们都是在一个称为帧缓冲区（frame buffer，简称fb）的硬件设备上进行渲染的。接下来，我们就分别分析这三个画面是如何在fb上显示的。 1. 第一个开机画面的显示过程 Android系统的第一个开机画面其实是Linux内核的启动画面。在默认情况下，这个画面是不会出现的，除非我们在编译内核的时候，启用以下两个编译选项： CONFIG_FRAMEBU...

2017-11-08

522

资源下载

更多资源

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。