android多线程,android多线程并发实例

每个Android 都应必须了解的多线程知识点~

进程是系统调度和资源分配的一个独立单位。

在Android中，一个应用程序就是一个独立的集成，应用运行在一个独立的环境中，可以避免其他应用程序/进程的干扰。当我们启动一个应用程序时，系统就会创建一个进程（该进程是从Zygote中fork出来的，有独立的ID），接着为这个进程创建一个主线程，然后就可以运行MainActivity了，应用程序的组件默认都是运行在其进程中。开发者可以通过设置应用的组件的运行进程，在清单文件中给组件设置：android:process = "进程名";可以达到让组件运行在不同进程中的目的。让组件运行在不同的进程中，既有好处，也有坏处。我们依次的说明下。

好处：每一个应用程序（也就是每一个进程）都会有一个内存预算，所有运行在这个进程中的程序使用的总内存不能超过这个值，让组件运行不同的进程中，可以让主进程可以拥有更多的空间资源。当我们的应用程序比较大，需要的内存资源比较多时（也就是用户会抱怨应用经常出现OutOfMemory时），可以考虑使用多进程。

坏处：每个进程都会有自己的虚拟机实例，因此让在进程间共享一些数据变得相对困难，需要采用进程间的通信来实现数据的共享。

线程是进程的一个实体，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。

在Android中，线程会有那么几种状态：创建、就绪、运行、阻塞、结束。当应用程序有组件在运行时，UI线程是处于运行状态的。默认情况下，应用的所有组件的操作都是在UI线程里完成的，包括响应用户的操作（触摸，点击等），组件生命周期方法的调用，UI的更新等。因此如果UI线程处理阻塞状态时(在线程里做一些耗时的操作，如网络连接等)，就会不能响应各种操作，如果阻塞时间达到5秒，就会让程序处于ANR（application not response）状态。

1.线程作用

减少程序在并发执行时所付出的时空开销，提高操作系统的并发性能。

2.线程分类

守护线程、非守护线程（用户线程）

2.1 守护线程

定义：守护用户线程的线程，即在程序运行时为其他线程提供一种通用服务

常见：如垃圾回收线程

设置方式：thread.setDaemon(true);//设置该线程为守护线程

2.2 非守护线程（用户线程）

主线程 子线程。

2.2.1 主线程（UI线程）

定义：Android系统在程序启动时会自动启动一条主线程

作用：处理四大组件与用户进行交互的事情（如UI、界面交互相关）

因为用户随时会与界面发生交互，因此主线程任何时候都必须保持很高的响应速度，所以主线程不允许进行耗时操作，否则会出现ANR。

2.2.2 子线程（工作线程）

定义：手动创建的线程

作用：耗时的操作（网络请求、I/O操作等）

2.3 守护线程与非守护线程的区别和联系

区别：虚拟机是否已退出，即

a. 当所有用户线程结束时，因为没有守护的必要，所以守护线程也会终止，虚拟机也同样退出

b. 反过来，只要任何用户线程还在运行，守护线程就不会终止，虚拟机就不会退出

3.线程优先级

3.1 表示

线程优先级分为10个级别，分别用Thread类常量表示。

3.2 设置

通过方法setPriority(int grade)进行优先级设置，默认线程优先级是5，即 Thread.NORM_PRIORITY。

4.线程状态

创建状态：当用 new 操作符创建一个线程的时候

就绪状态：调用 start 方法，处于就绪状态的线程并不一定马上就会执行 run 方法，还需要等待CPU的调度

运行状态：CPU 开始调度线程，并开始执行 run 方法

阻塞（挂起）状态：线程的执行过程中由于一些原因进入阻塞状态，比如：调用 sleep/wait 方法、尝试去得到一个锁等

结束（消亡）状态：run 方法执行完 或者 执行过程中遇到了一个异常

（1）start()和run()的区别

通过调用Thread类的start()方法来启动一个线程，这时此线程是处于就绪状态，并没有运行。调用Thread类调用run()方法来完成其运行操作的，方法run()称为线程体，它包含了要执行的这个线程的内容，run()运行结束，此线程终止，然后CPU再调度其它线程。

（2）sleep()、wait()、yield()的区别

sleep()方法属于Thread类，wait()方法属于Object类。

调用sleep()方法，线程不会释放对象锁，只是暂停执行指定的时间，会自动恢复运行状态；调用wait()方法，线程会放弃对象锁，进入等待此对象的等待锁定池，不调用notify()方法，线程永远处于就绪（挂起）状态。

yield()直接由运行状态跳回就绪状态，表示退让线程，让出CPU，让CPU调度器重新调度。礼让可能成功，也可能不成功，也就是说，回到调度器和其他线程进行公平竞争。

1.Android线程的原则

（1）为什么不能再主线程中做耗时操作

防止ANR, 不能在UI主线程中做耗时的操作，因此我们可以把耗时的操作放在另一个工作线程中去做。操作完成后，再通知UI主线程做出相应的响应。这就需要掌握线程间通信的方式了。 在Android中提供了两种线程间的通信方式：一种是AsyncTask机制，另一种是Handler机制。

（2）为什么不能在非UI线程中更新UI 因为Android的UI线程是非线程安全的，应用更新UI，是调用invalidate()方法来实现界面的重绘，而invalidate()方法是非线程安全的，也就是说当我们在非UI线程来更新UI时，可能会有其他的线程或UI线程也在更新UI，这就会导致界面更新的不同步。因此我们不能在非UI主线程中做更新UI的操作。

2.Android实现多线程的几种方式

3.为何需要多线程

多线程的本质就是异步处理，直观一点说就是不要让用户感觉到“很卡”。

4.多线程机制的核心是啥

多线程核心机制是Handler

推荐Handler讲解视频： 面试总被问到Handler？带你从源码的角度解读Handler核心机制

根据上方提到的 多进程、多线程、Handler 问题，我整理了一套 Binder与Handler 机制解析的学习文档，提供给大家进行学习参考，有需要的可以 点击这里直接获取！！！ 里面记录许多Android 相关学习知识点。

相关问答

Q1: Android多线程的四种方式：Handler、AsyncTask、ThreadPoolExector、IntentService

     异步通信机制，将工作线程中需更新UI的操作信息 传递到 UI主线程，从而实现 工作线程对UI的更新处理，最终实现异步消息的处理。Handler不仅仅能将子线程的数据传递给主线程，它能实现任意两个线程的数据传递。

（1）Message

    Message 可以在线程之间传递消息。可以在它的内部携带少量数据，用于在不同线程之间进行数据交换。除了 what 字段，还可以使用 arg1 和 arg2 来携带整型数据，使用 obj 来携带 Object 数据。

（2） Handler

    Handler 作为处理中心，用于发送（sendMessage 系列方法）与处理消息（handleMessage 方法）。

（3） MessageQueue

    MessageQueue 用于存放所有通过 Handler 发送的消息。这部分消息会一直存放在消息队列中，直到被处理。每个线程中只会有一个 MessageQueue 对象

（4） Looper

    Looper 用于管理 MessageQueue 队列，Looper对象通过loop()方法开启了一个死循环——for (;;)｛｝，不断地从looper内的MessageQueue中取出Message，并传递到 Handler 的 handleMessage() 方法中。每个线程中只会有一个 Looper 对象。

    AsyncTask 是一种轻量级的任务异步类，可以在后台子线程执行任务，且将执行进度及执行结果传递给 UI 线程。

（1）onPreExecute()

    在 UI 线程上工作，在任务执行 doInBackground() 之前调用。此步骤通常用于设置任务，例如在用户界面中显示进度条。

（2）doInBackground(Params... params)

    在子线程中工作，在 onPreExecute() 方法结束后执行，这一步被用于在后台执行长时间的任务，Params 参数通过 execute(Params) 方法被传递到此方法中。任务执行结束后，将结果传递给 onPostExecute(Result) 方法，同时我们可以通过 publishProgress(Progress) 方法，将执行进度发送给 onProgressUpdate(Progress) 方法。

（3）onProgressUpdate(Progress... values)

    在 UI 线程上工作，会在 doInBackground() 中调用 publishProgress(Progress) 方法后执行，此方法用于在后台计算仍在执行时(也就是 doInBackgound() 还在执行时)将计算执行进度通过 UI 显示出来。例如，可以通过动画进度条或显示文本字段中的日志，从而方便用户知道后台任务执行的进度。

（4）onPostExecute(Result result)

    在 UI 线程上工作，在任务执行完毕（即 doInBackground(Result) 执行完毕）并将执行结果传过来的时候工作。

使用规则：

（1）AsyncTask 是个抽象类，所以要创建它的子类实现抽象方法

（1）AsyncTask 类必须是在 UI 线程中被加载，但在Android 4.1（API 16）开始，就能被自动加载完成。

（2）AsyncTask 类的实例对象必须在 UI 线程中被创建。

（3）execute() 方法必须是在 UI 线程中被调用。

（4）不要手动调用方法 onPreExecute()、onPostExecute()、doInBackground()、onProgressUpdate()

（5）任务只能执行一次(如果尝试第二次执行，将抛出异常)。即一个AsyncTask对象只能调用一次execute()方法。

原理：

          其源码中原理还是 Thread 与 Handler 的实现，其包含 两个线程池，一个 Handler，如下所示：

名称类型作用

SERIAL_EXECUTOR线程池分发任务，串行分发，一次只分发一个任务

THREAD_POOL_EXECUTOR线程池执行任务，并行执行，执行的任务由 SERIAL_EXECUTOR 分发

InternalHandlerHandler负责子线程与主线程的沟通，通知主线程做 UI 工作

    一方面减少了每个并行任务独自建立线程的开销，另一方面可以管理多个并发线程的公共资源，从而提高了多线程的效率。所以ThreadPoolExecutor比较适合一组任务的执行。Executors利用工厂模式对ThreadPoolExecutor进行了封装。

Executors提供了四种创建ExecutorService的方法，他们的使用场景如下：

1. Executors.newFixedThreadPool()

    创建一个定长的线程池，每提交一个任务就创建一个线程，直到达到池的最大长度，这时线程池会保持长度不再变化。

当线程处于空闲状态时，它们并不会被回收，除非线程池被关闭。当所有的线程都处于活动状态时，新任务都会处于等待状态，直到有线程空闲出来。

只有核心线程并且不会被回收，能够更加快速的响应外界的请求。

2. Executors.newCachedThreadPool()

    创建一个可缓存的线程池，如果当前线程池的长度超过了处理的需要时，它可以灵活的回收空闲的线程，当需要增加时，它可以灵活的添加新的线程，而不会对池的长度作任何限制

    线程数量不定的线程池，只有非核心线程，最大线程数为 Integer.MAX_VALUE。当线程池中的线程都处于活动状态时，线程池会创建新的线程来处理新任务，否则利用空闲的线程来处理新任务。线程池中的空闲线程具有超时机制，为 60s。

    任务队列相当于一个空集合，导致任何任务都会立即被执行，适合执行大量耗时较少的任务。当整个线程池都处于限制状态时，线程池中的线程都会超时而被停止。

3. Executors.newScheduledThreadPool()

    创建一个定长的线程池，而且支持定时的以及周期性的任务执行，类似于Timer。

    非核心线程数没有限制，并且非核心线程闲置的时候立即回收，主要用于执行定时任务和具有固定周期的重复任务。

4. Executors.newSingleThreadExecutor()

    创建一个单线程化的executor，它只创建唯一的worker线程来执行任务

    只有一个核心线程，保证所有的任务都在一个线程中顺序执行，意义在于不需要处理线程同步的问题。

    一般用于执行后台耗时任务，当任务执行完成会自动停止；同时由于它是一个服务，优先级要远远高于线程，更不容易被系统杀死，因此比较适合执行一些高优先级的后台任务。

使用步骤：创建IntentService的子类，重写onHandleIntent方法，在onHandleIntent中执行耗时任务

    原理：在源码实现上，IntentService封装了HandlerThread和Handler。onHandleIntent方法结束后会调用IntentService的stopSelf(int startId)方法尝试停止服务。

    IntentService的内部是通过消息的方式请求HandlerThread执行任务，HandlerThread内部又是一种使用Handler的Thread，这就意味着IntentService和Looper一样是顺序执行后台任务的

（HandlerThread：封装了Handler + ThreadHandlerThread适合在有需要一个工作线程（非UI线程）+任务的等待队列的形式，优点是不会有堵塞，减少了对性能的消耗，缺点是不能同时进行多个任务的处理，需要等待进行处理。处理效率低，可以当成一个轻量级的线程池来用）

Q2: Android开发之路-多线程

多线程作为Android开发中相对而言较为高阶的知识，其中用到相关的知识点是非常的多，所以在我们需要进行设计或者写多线程的代码就必须要进行相对谨慎的处理，这样就由必要对其要有着比较系统化的认知

我们一般将Android应用分成为两种：主线程和工作线程；主线程主要是用来进行初始化UI，而工作线程主要是进行耗时操作，例如读取数据库，网络连接等

Android系统是以进程为单位来对应用程序资源进行限制，这个问题的可以解释为：一个进程最多能够开几个线程？最好能开几个？但实则这个是没有上限这一说，主要是因为资源的限制

Android中关于主线程的理解：Android的主线程是UI线程，在Android中，四大组件运行在主线程中，在主线程中做耗时操作会导致程序出现卡顿甚至出现ANR异常，一个.

在一个程序中，这些独立运行的程序片断叫作“线程”(Thread)，利用它编程的概念就叫作“多线程处理”。多线程处理一个常见的例子就是用户界面。

线程总的来就是进程的一个实体，是CPU进行分派和调度的基本单位，拥有着比进程更小且能够独立运行的基本单位，线程本身基本上是不拥有系统资源，仅拥有一点在运行过程中必须拥有的资源，但它可与同属一个进程中的其他进程进行共享其所拥有的所有资源

线程状态有些地方将之分为5中状态，而且在Java Jdk中线程被其定义为6中状态，我们可以对其进行类比

普遍定义的5中状态：新建，就绪，运行，阻塞， 死亡

Java Jdk 定义状态

线程阻塞是指在某一时刻的某一个线程在进行运行一段代码的情况下，突然另一个线程也要进行运行，但在运行过程中，那个线程执行完全运行之前，另一个线程是不可能获取到CPU的执行权，就会导致线路阻塞的出现

死锁也称之为抱死，意思就是说一个进程锁定了另外一个进程所需要的页或表是，但第二个进程同时又锁定了第一个进程所需的一页，这样就会出现死锁现象

简要介绍实现线程的三种方式：继承Thread，实现runnable，实现callable。这里有一点需要注意的是，实现callable是与线程池相关联的而callable很重要的一个特性是其带有返回值。当我们只需实现单线程时实现runnable更加利于线程程序的拓展

在线程开启之前进行调用 thread.setDaemon(true); 将thread设定成当前线程中的守护线程 使用案例

线程让步【yield方法】让当前线程释放CPU资源，让其他线程抢占

这种具体某个对象锁 wait notify 方法与Condition 的 await以及signal方法类似； 全面这种方法的阻塞等待都可以是释放锁，而且在唤醒后，这种线程都是能够获取锁资源的，而这个门栓就跟阀门类似