Android中的多线程【转】

感谢大佬：https://www.cnblogs.com/zoe-mine/p/7954605.html

感谢大佬：https://blog.csdn.net/u014555121/article/details/69218761

Android多线程

Android中的多线程本质上也是Java的多线程，同时添加了一些不同的特性和使用的场景。其中，最主要的一个区别就是Android中主线程和子线程中的区分，Android中的主线程是UI线程，负责运行四大组件并与用户实现交互，需要保持较高的反应速度，所以主线程不允许进行耗时的操作（比如说网络请求和访问），否则容易出现ANR现象，子线程则负责处理 一些耗时的任务，而如果子线程中想要实现对UI的操作，则需要通过Android的handler消息机制。

为什么子线程中不允许对UI进行操作呢

因为Android的UI控件并不是线程安全，多线程的并发访问会带来UI控件的不可预期的状态，且考虑到加锁机制会带来性能上的问题，因此Android在设计初期就禁止子线程处理UI。UI操作时ViewRootImpl会对操作者所在的线程进行checkThread，如果非主线程，会抛出CalledFromWrongThreadException。

线程和进程的区别

线程和进程的本质：由CPU进行调度的并发式执行任务，多个任务被快速轮换执行，使得宏观上具有多个线程或者进程同时执行的效果。

进程：在操作系统来说，一个运行的程序或者说一个动态的指令集合通常对应一个进程Process，它是系统进行资源分配和调度的一个独立单位，也是拥有系统资源的基本单位。进程是系统中独立存在的实体，它可以拥有自己独立的资源，拥有自己私有的地址空间，进程之间不能直接访问其他进程的地址空间。

线程：线程是CPU调度的基本单位，也就是说在一个进程中可以有多个并发程序执行流，线程拓展了进程的概念，使得任务的执行得到更加的细分，所以Thread有时候也被称为Lightweight Process。线程是进程的执行单元，但是线程不是分配系统资源的单位，它们共享所在进程的资源，包括共享内存，公有数据，全局变量，进程文件描述符，进程处理器，进程代码段，进程用户ID等等。

线程独立拥有自己的线程ID，堆栈，程序计数器，局部变量，寄存器组值，优先级，信号屏蔽码，错误返回码等等，线程是独立运行的，其执行是抢占式的。线程共享进程资源，线程之间的通信要进程之间的通信来得容易得多。此外，线程的创建和销毁的开销也远远小于进程的系统开销。

线程和线程池

线程池：虽然线程的创建销毁的开销相对较小，但是频繁得创建和销毁也会消耗有限的资源，从而带来性能上的浪费，也不够高效。因此线程池的出，现就是为了解决这一问题，即在初始状态创建并维护一定数量的空闲线程，当有需要执行的任务，就交付给线程中的一个线程，任务执行结束后，该线程也不会死亡，而是回到线程池中重新变为空闲状态。

线程池的好处：减少线程频繁创建销毁的资源开销，同时能够有效控制系统中并发线程的数量，防止系统性能的剧烈下降。

简易示例

首先，新建异步消息实例：

private Handler handler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
        switch (msg.what) {
            case CHANGE_CONTENT:
                textView.setText("饭吃了吗？");
                break;
            default:
                break;
        }
    }
};

使用异步消息来更新 UI：

findViewById(R.id.change).setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    Message message = new Message();
                    message.what = CHANGE_CONTENT;
                    handler.sendMessage(message);
                }
            }).start();
        }
    });

Message

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

注意：一个Message对象的arg1只能发送一次

Handler

Handler 用于发送（sendMessage 系列方法）与处理消息（handleMessage 方法）。

3.2 MessageQueue

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

Looper

Looper 用于管理 MessageQueue 队列，调用 Looper.loop() 方法之后，就会进入无限循环中，每当发现 MessageQueue 存在一条消息，就会将它取出，并传递到 Handler 的 handleMessage() 方法中。每个线程中只会有一个 Looper 对象。

异步消息处理流程



1、在主线程中创建 Handler 对象，并重写 handleMessage() 方法。

2、子线程进行 UI 操作时，创建 Message 对象，通过 Handler 发送这条消息。

3、Looper 从 MessageQueue 中取出待处理消息。

4、最后分发回 Handler 的 handleMessage() 方法中。

Message 经过一系列流转调用后，也就从子线程进入到主线程，这样就可以执行更新 UI 的操作啦 O(∩_∩)O哈哈~

总结

1. Android 的 UI 是线程不安全的，所以如果想要更新应用程序的 UI 元素，就必须在主线程中进行，否则会抛出异常（CalledFromWrongThreadException） 。
2. 在子线程中，必须使用异步消息处理机制来更新 UI。

---

结束线程有以下三种方法：

（1）设置退出标志，使线程正常退出，也就是当run()方法完成后线程终止

（2）使用interrupt()方法中断线程

（3）使用stop方法强行终止线程（不推荐使用，Thread.stop, Thread.suspend, Thread.resume 和

Runtime.runFinalizersOnExit 这些终止线程运行的方法已经被废弃，使用它们是极端不安全的！）

stop()方法太过于暴力，会强行把执行一半的线程终止。这样会就不会保证线程的资源正确释放，通常是没有给与线程完成资源释放工作的机会，因此会导致程序工作在不确定的状态下

分割线_

1.使用退出标志终止线程

一般run()方法执行完，线程就会正常结束，然而，常常有些线程是伺服线程。它们需要长时间的运行，只有在外部某些条件满足的情况下，才能关闭这些线程。使用一个变量来控制循环，例如：最直接的方法就是设一个boolean类型的标志，并通过设置这个标志为true或false来控制while循环是否退出，代码示例：

public class ThreadSafe extends Thread {
public volatile boolean exit = false;
public void run() {
while (!exit){
//do something
}
}
}

定义了一个退出标志exit，当exit为true时，while循环退出，exit的默认值为false.在定义exit时，使用了一个Java关键字volatile，这个关键字的目的是使exit同步，也就是说在同一时刻只能由一个线程来修改exit的值.

2.使用interrupt()方法中断当前线程

使用interrupt()方法来中断线程有两种情况：

1)线程处于阻塞状态，如使用了sleep,同步锁的wait,socket中的receiver,accept等方法时，会使线程处于阻塞状态。当调用线程的interrupt()方法时，会抛出InterruptException异常。阻塞中的那个方法抛出这个异常，通过代码捕获该异常，然后break跳出循环状态，从而让我们有机会结束这个线程的执行。通常很多人认为只要调用interrupt方法线程就会结束，实际上是错的， 一定要先捕获InterruptedException异常之后通过break来跳出循环，才能正常结束run方法。

代码示例：

public class ThreadSafe extends Thread {
public void run() {
while (true){
try{
Thread.sleep(5*1000);//阻塞5妙
}catch(InterruptedException e){
e.printStackTrace();
break;//捕获到异常之后，执行break跳出循环。
}
}
}
}

2)线程未处于阻塞状态，使用isInterrupted()判断线程的中断标志来退出循环。

当使用interrupt()方法时，中断标志就会置true，和使用自定义的标志来控制循环是一样的道理。

代码示例：

public class ThreadSafe extends Thread {
public void run() {
while (!isInterrupted()){
//do something, but no throw InterruptedException
}
}
}

    为什么要区分进入阻塞状态和和非阻塞状态两种情况了，是因为当阻塞状态时，如果有interrupt()发生，系统除了会抛出InterruptedException异常外，还会调用interrupted()函数，调用时能获取到中断状态是true的状态，调用完之后会复位中断状态为false，所以异常抛出之后通过isInterrupted()是获取不到中断状态是true的状态，从而不能退出循环，因此在线程未进入阻塞的代码段时是可以通过isInterrupted()来判断中断是否发生来控制循环，在进入阻塞状态后要通过捕获异常来退出循环。因此使用interrupt()来退出线程的最好的方式应该是两种情况都要考虑：

代码示例：

public class ThreadSafe extends Thread {
public void run() {
while (!isInterrupted()){ //非阻塞过程中通过判断中断标志来退出
try{
Thread.sleep(5*1000);//阻塞过程捕获中断异常来退出
}catch(InterruptedException e){
e.printStackTrace();
break;//捕获到异常之后，执行break跳出循环。
}
}
}
}

3.使用stop方法终止线程

    程序中可以直接使用thread.stop()来强行终止线程，但是stop方法是很危险的，就象突然关闭计算机电源，而不是按正常程序关机一样，可能会产生不可预料的结果，不安全主要是：thread.stop()调用之后，创建子线程的线程就会抛出ThreadDeatherror的错误，并且会释放子线程所持有的所有锁。一般任何进行加锁的代码块，都是为了保护数据的一致性，如果在调用thread.stop()后导致了该线程所持有的所有锁的突然释放(不可控制)，那么被保护数据就有可能呈现不一致性，其他线程在使用这些被破坏的数据时，有可能导致一些很奇怪的应用程序错误。因此，并不推荐使用stop方法来终止线程。

---

附我们的教材介绍：