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 相关学习知识点。

android 主线程和子线程有什么区别

本文较为深入的分析了android中UI主线程与子线程。分享给大家供大家参考。具体如下：

在一个Android 程序开始运行的时候，会单独启动一个Process。默认的情况下，所有这个程序中的Activity或者Service（Service和 Activity只是Android提供的Components中的两种，除此之外还有Content Provider和Broadcast Receiver）都会跑在这个Process。

一个Android 程序默认情况下也只有一个Process，但一个Process下却可以有许多个Thread。在这么多Thread当中，有一个Thread，我们称之为UI Thread。UI Thread在Android程序运行的时候就被创建，是一个Process当中的主线程Main Thread，主要是负责控制UI界面的显示、更新和控件交互。在Android程序创建之初，一个Process呈现的是单线程模型，所有的任务都在一个线程中运行。因此，我们认为，UI Thread所执行的每一个函数，所花费的时间都应该是越短越好。而其他比较费时的工作（访问网络，下载数据，查询数据库等），都应该交由子线程去执行，以免阻塞主线程。

那么，UI Thread如何和其他Thread一起工作呢？常用方法是：诞生一个主线程的Handler物件，当做Listener去让子线程能将讯息Push到主线程的Message Quene里，以便触发主线程的handlerMessage（）函数，让主线程知道子线程的状态，并在主线程更新UI。

例如，在子线程的状态发生变化时，我们需要更新UI。如果在子线程中直接更新UI,通常会抛出下面的异常：

11-07 13:33:04.393: ERROR/JavaBinder(1029):android.view.ViewRoot$CalledFromWrongThreadException:Only the original thread that created a view hierarchy can touch its views.

意思是，无法在子线程中更新UI。为此，我们需要通过Handler物件，通知主线程Ui Thread来更新界面。

如下，首先创建一个Handler,来监听Message的事件：

private final int UPDATE_UI = 1;

private Handler mHandler = new MainHandler();

private class MainHandler extends Handler {

@Override

public void handleMessage(Message msg) {

switch (msg.what) {

case UPDATE_UI: {

Log.i("TTSDeamon", "UPDATE_UI");

showTextView.setText(editText.getText().toString());

ShowAnimation();

break;

}

default:

break;

}

}

}

或者：

private Handler mHandler = new Handler(){

@Override

public void handleMessage(Message msg) {

switch (msg.what) {

case UPDATE_UI: {

Log.i("TTSDeamon", "UPDATE_UI");

showTextView.setText(editText.getText().toString());

ShowAnimation();

break;

}

default:

break;

}

}

}

当子线程的状态发生变化，则在子线程中发出Message，通知更新UI。

mHandler.sendEmptyMessageDelayed(UPDATE_UI, 0);

在我们的程序中，很多Callback方法有时候并不是运行在主线程当中的，所以如果在Callback方法中更新UI失败，也可以采用上面的方法。

Android UI线程

思考：

先必须了解下面2个问题

1.顾名思义 UI线程 就是刷新UI 所在线程

2.UI是单线程刷新

1.对Activity 来说 UI线程就是其主线程

2.对View来说 UI线程就是创建ViewRootImpl所在的线程

可以通过 WindowManager 内部会创建ViewRootImpl对象

好了，进入主题。我们来慢慢揭开面纱。

我们可以分别从几个方面切入

我们可能都有使用过 runOnUiThread 现在来看看的源码实现。

可以从上面的源码 看到

不是UI线程 就用Handler切到Handler所在的线程中，如果是UI线程直接就调用run方法。

Activity的创建：

1.Activity创建：mInstrumentation.newActivity

2.创建Context ：ContextImpl appContextcreateBaseContextForActivity(r)

我们经常用这个方法干的事情就是，要么在onCreate中获取View宽高的值。要么就是在子线程中做一些耗时操作 ，然后post切到对应View所在的线程 来绘制UI操作。那么这个对应的线程就是UI线程了。

那么这个UI线程就一定是主线程吗？

接来继续来看。它的源码View:post

mAttachInfo 在dispatchAttachedToWindow 中被赋值 ，也就是在ViewRootImpl创建的时候，所以是创建ViewRootImpl所在的线程。

attachInfo 上面时候为null 呢？在ViewRootImpl 还没来得及创建的时候，ViewRootImpl 创建是在 “onResume" 之后。所以在 Activity 的 onCreate 去View.post 那么AttachInfo 是为null 。

当 AttachInfo == null 那么会调用 getRunQueue().post(action) 。

最终这个Runnable 被 缓存到 HandlerActionQueue 中。

直到ViewRootImpl 的 performTraversals 中 调用dispatchAttachedToWindow(mAttachInfo, 0);， 那么才会去处理 RunQueue() 中的Runnable。

来张图 便于理解这个流程

我们有时候去子线程操作UI的时候(如：requestLayout)，会很经常见到下面的 报错日志：

Only the original thread that created a view hierarchy can touch its views

为什么会报这个错误呢？

翻译一下：只有创建视图层次结构的原始线程才能接触到它的视图。

也就是操作UI的线程要和ViewRootImpl创建的线程是同一个线程才行，并不是只有主线程才能更新UI啊。

ViewRootImpl创建的线程？那么 ViewRootImpl 在哪里被创建的呢？

从上图可以看到ViewRootImpl创建最开始是从 ActivityThread 的HandleResumeActivity中开始 一直 ViewRootImpl 创建，也就是说ViewRootImpl 对应的UI线程和 ActivityThread 在同一个线程 也就是主线程。

好了 通过上面的讲解，上面的问题相信你可以自己回答啦~

Android线程池的使用

在Android中有主线程和子线程的区分。主线程又称为UI线程，主要是处理一些和界面相关的事情，而子线程主要是用于处理一些耗时比较大的一些任务，例如一些网络操作，IO请求等。如果在主线程中处理这些耗时的任务，则有可能会出现ANR现象（App直接卡死）。

线程池，从名字的表明含义上我们知道线程池就是包含线程的一个池子，它起到新建线程、管理线程、调度线程等作用。

既然Android中已经有了线程的概念，那么为什么需要使用线程池呢？我们从两个方面给出使用线程池的原因。

在Android中线程池就是ThreadPoolExecutor对象。我们先来看一下ThreadPoolExecutor的构造函数。

我们分别说一下当前的几个参数的含义：

第一个参数corePoolSize为 核心线程数 ，也就是说线程池中至少有这么多的线程，即使存在的这些线程没有执行任务。但是有一个例外就是，如果在线程池中设置了allowCoreThreadTimeOut为true，那么在 超时时间（keepAliveTime） 到达后核心线程也会被销毁。

第二个参数maximumPoolSize为 线程池中的最大线程数 。当活动线程数达到这个数后，后续添加的新任务会被阻塞。

第三个参数keepAliveTime为 线程的保活时间 ，就是说如果线程池中有多于核心线程数的线程，那么在线程没有任务的那一刻起开始计时，如果超过了keepAliveTime，还没有新的任务过来，则该线程就要被销毁。同时如果设置了allowCoreThreadTimeOut为true，该时间也就是上面第一条所说的 超时时间 。

第四个参数unit为 第三个参数的计时单位 ，有毫秒、秒等。

第五个参数workQueue为 线程池中的任务队列 ，该队列持有由execute方法传递过来的Runnable对象（Runnable对象就是一个任务）。这个任务队列的类型是BlockQueue类型，也就是阻塞队列，当队列的任务数为0时，取任务的操作会被阻塞；当队列的任务数满了（活动线程达到了最大线程数），添加操作就会阻塞。

第六个参数threadFactory为 线程工厂 ，当线程池需要创建一个新线程时，使用线程工厂来给线程池提供一个线程。

第七个参数handler为 拒绝策略 ，当线程池使用有界队列时（也就是第五个参数），如果队列满了，任务添加到线程池的时候的一个拒绝策略。

可以看到FixedThreadPool的构建调用了ThreadPoolExecutor的构造函数。从上面的调用中可以看出FixedThreadPool的几个特点：

可以看到CacheThreadPool的构建调用了ThreadPoolExecutor的构造函数。从上面的调用中可以看出CacheThreadPool的几个特点：

可以看到ScheduledThreadPoolExecutor的构建调用了ThreadPoolExecutor的构造函数。从上面的调用中可以看出ScheduledThreadPoolExecutor的几个特点：

可以看到SingleThreadExecutor的构建调用了ThreadPoolExecutor的构造函数。从上面的调用中可以看出SingleThreadExecutor的几个特点：

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方法类似； 全面这种方法的阻塞等待都可以是释放锁，而且在唤醒后，这种线程都是能够获取锁资源的，而这个门栓就跟阀门类似

Android进程间和线程间通信方式

  进程：是具有一定独立功能的程序关于某个数据集合上的一次运行活动，进程是系统进行资源分配和调度的一个独立单位。

  线程：是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源,只拥有一些在运行中必不可少的资源(如程序计数器,一组寄存器和栈)，但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。

  区别：

  （1）、一个程序至少有一个进程，一个进程至少有一个线程；

  （2）、线程的划分尺度小于进程，使得多线程程序的并发性高；

  （3）、进程在执行过程中拥有独立的内存单元，而多个线程共享内存，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉。

---------------------

一、Android进程间通信方式

1.Bundle

  由于Activity，Service，Receiver都是可以通过Intent来携带Bundle传输数据的，所以我们可以在一个进程中通过Intent将携带数据的Bundle发送到另一个进程的组件。

  缺点：无法传输Bundle不支持的数据类型。

2.ContentProvider

  ContentProvider是Android四大组件之一，以表格的方式来储存数据，提供给外界，即Content Provider可以跨进程访问其他应用程序中的数据。用法是继承ContentProvider，实现onCreate,query,update,insert,delete和getType方法，onCreate是负责创建时做一些初始化的工作，增删查改的方法就是对数据的查询和修改，getType是返回一个String，表示Uri请求的类型。注册完后就可以使用ContentResolver去请求指定的Uri。

3.文件

  两个进程可以到同一个文件去交换数据，我们不仅可以保存文本文件，还可以将对象持久化到文件，从另一个文件恢复。要注意的是，当并发读/写时可能会出现并发的问题。

4.Broadcast

  Broadcast可以向android系统中所有应用程序发送广播，而需要跨进程通讯的应用程序可以监听这些广播。

5.AIDL方式

  Service和Content Provider类似，也可以访问其他应用程序中的数据，Content Provider返回的是Cursor对象，而Service返回的是Java对象，这种可以跨进程通讯的服务叫AIDL服务。

     AIDL通过定义服务端暴露的接口，以提供给客户端来调用，AIDL使服务器可以并行处理，而Messenger封装了AIDL之后只能串行运行，所以Messenger一般用作消息传递。

6.Messenger

  Messenger是基于AIDL实现的，服务端（被动方）提供一个Service来处理客户端（主动方）连接，维护一个Handler来创建Messenger，在onBind时返回Messenger的binder。

  双方用Messenger来发送数据，用Handler来处理数据。Messenger处理数据依靠Handler，所以是串行的，也就是说，Handler接到多个message时，就要排队依次处理。

7.Socket

  Socket方法是通过网络来进行数据交换，注意的是要在子线程请求，不然会堵塞主线程。客户端和服务端建立连接之后即可不断传输数据，比较适合实时的数据传输

二、Android线程间通信方式

  一般说线程间通信主要是指主线程（也叫UI线程）和子线程之间的通信，主要有以下两种方式：

1.AsyncTask机制

  AsyncTask，异步任务，也就是说在UI线程运行的时候，可以在后台的执行一些异步的操作；AsyncTask可以很容易且正确地使用UI线程，AsyncTask允许进行后台操作，并在不显示使用工作线程或Handler机制的情况下，将结果反馈给UI线程。但是AsyncTask只能用于短时间的操作（最多几秒就应该结束的操作），如果需要长时间运行在后台，就不适合使用AsyncTask了，只能去使用Java提供的其他API来实现。

2.Handler机制

  Handler，继承自Object类，用来发送和处理Message对象或Runnable对象；Handler在创建时会与当前所在的线程的Looper对象相关联(如果当前线程的Looper为空或不存在，则会抛出异常，此时需要在线程中主动调用Looper.prepare()来创建一个Looper对象)。使用Handler的主要作用就是在后面的过程中发送和处理Message对象和让其他的线程完成某一个动作（如在工作线程中通过Handler对象发送一个Message对象，让UI线程进行UI的更新，然后UI线程就会在MessageQueue中得到这个Message对象（取出Message对象是由其相关联的Looper对象完成的），并作出相应的响应）。

三、Android两个子线程之间通信

  面试的过程中，有些面试官可能会问Android子线程之间的通信方式，由于绝大部分程序员主要关注的是Android主线程和子线程之间的通信，所以这个问题很容易让人懵逼。

  主线程和子线程之间的通信可以通过主线程中的handler把子线程中的message发给主线程中的looper，或者，主线程中的handler通过post向looper中发送一个runnable。但looper默认存在于main线程中，子线程中没有Looper，该怎么办呢？其实原理很简单，把looper绑定到子线程中，并且创建一个handler。在另一个线程中通过这个handler发送消息，就可以实现子线程之间的通信了。

  子线程创建handler的两种方式：

  方式一：给子线程创建Looper对象：

new Thread(new Runnable() {

        public void run() { 

            Looper.prepare();  // 给这个Thread创建Looper对象，一个Thead只有一个Looper对象

            Handler handler = new Handler(){ 

                @Override 

                public void handleMessage(Message msg) { 

                    Toast.makeText(getApplicationContext(), "handleMessage", Toast.LENGTH_LONG).show(); 

                } 

            }; 

            handler.sendEmptyMessage(1); 

            Looper.loop(); // 不断遍历MessageQueue中是否有消息

        }; 

    }).start();

---------------------

   方式二：获取主线程的looper，或者说是UI线程的looper：

new Thread(new Runnable() {

        public void run() { 

            Handler handler = new Handler(Looper.getMainLooper()){ // 区别在这！！！ 

                @Override 

                public void handleMessage(Message msg) { 

                    Toast.makeText(getApplicationContext(), "handleMessage", Toast.LENGTH_LONG).show(); 

                } 

            }; 

            handler.sendEmptyMessage(1); 

        }; 

    }).start();

---------------------