线程

1、线程与进程
2、线程的创建和启动
3、Message与Handler（消息处理机制）

一、线程与进程

进程：指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。
多进程：指操作系统能同时运行多个任务。
线程：进程中的一个执行流程，一个进程中可以运行多个线程，一个线程必须有一个父进程。
多线程：指程序中包含多条执行流经，即在一个进程中可同时执行两个或以上的线程，大多是程序只有一条执行路线，但现实世界中很多过程都是同时发生的，对于这种情况，可编写多条执行路径的程序，使程序可以同时执行多个任务。（多线程机制使得程序的多个子任务能够同时执行）

在java中要想实现多线程，有两种方法，继承Thread类和实现Run那不可接口。

进程与线程的区别
进程是独立的地址空间而线程没有；线程不能独立存在，它是由进程创建的，线程的耗费CPU和内存小于进程。
一个进程中可以有多个线程，但是线程必须有一个父进程。（进程包含线程，线程构成进程）

Android中的进程：
进程的优先级由高到低分别是：前台进程，可见进程，服务进程，后台进程，空进程。

1、前台进程（foreground Process，可见可操作，onResume方法被调用）

前台进程是用户当前正在使用的进程。只有一些前台进程可以在任何时候都存在。他们是最后一个被结束的，当内存低到根本连他们都不能运行的时候。一般来说， 在这种情况下，设备会进行内存调度，中止一些前台进程来保持对用户交互的响应。

　
　如下情形就是前台进程：
　　处于Activity Resume状态（失去焦点，但是对于用户是能看到activity）。
　　处于与bound服务交互的状态。
　　处于服务在前台的状态（Service调用startService，强制提高service的优先级）。
　　Service生命周期函数正在被执行（onCreate，onStart，onDestroy）。
　　Broadcast Receiver正在执行onReceive方法。

2、可见进程（Visible Process，可见不可操作，onPause方法被调用）

可见进程优先级仅次于前台进程，所以一般很少被kill，除非需要更多的资源来运行前台进程。

如下情形是就是可见进程：

• Activity不在前台显示，但也没有隐藏，activity处于pause状态，比如弹出一个对话框；
• 这个进程里有一个绑定到一个可见的activity的Service。

3、服务进程（Service Process）
运行着一个通过startService方法启动的service，这个Service不属于上面提到的两种情况，虽然Service没有直接绑定在用户可见的UI上，但是一些比较重要的事情（网上下载文件、后台播放音乐等）还是很受用户关心的，所以系统会保持运行除非比他高的等级进程运行。该进程不到万不得已不会被回收，而且即便是被回收了，内存充足是也会被启动。

4、后台进程（Background Process，onStop方法被调用，易被回收—home键）
运行着一个对用户不可见的activity（调用过 onStop() 方法).这些进程对用户体验没有直接的影响，可以在服务进程、可见进程、前台进 程需要内存的时候回收。通常，系统中会有很多不可见进程在运行，他们被保存在LRU (least recently used) 列表中，以便内存不足的时候被第一时间回收。如果一个activity正 确的执行了它的生命周期，关闭这个进程对于用户体验没有太大的影响。

5、空进程（Empty Process，没有运行任何activity，易被回收—返回键）
未运行任何程序组件。运行这些进程的唯一原因是作为一个缓存，缩短下次程序需要重新使用的启动时间。系统经常中止这些进程，这样可以调节程序缓存和系统缓存的平衡。

二、线程的创建和启动

方式1：

1. 定义一个类并继承Thread类
2. 覆写Thread中的run方法
3. 创建子类对象来创建线程
4. 调用start方法启动线程并执行run方法

//定义一个类继承Thread
public class Thread1 extends Thread{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println("Count:"+i);
        }

    }

}

//主函数,启动线程
public class main {

    public static void main(String[] args){
        Thread1 thread = new Thread1();
        thread.start();
    }
}

方式2：

1. 定义类并实现Runnable接口
2. 覆写run方法，封装数据
3. 通过Thread创建线程对象，并将Runnable子类的对象作为参数，用在Thread构造器中
4. 调用线程对象的start方法

//创建类实现Runnable接口
public class RunnableThread implements Runnable{
//重写run方法
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println("Count："+i);
        }   
    }
}


//主函数
public class main {

    public static void main(String[] args){
        RunnableThread rt = new RunnableThread();
        Thread thread = new Thread(rt);
        thread.start();
    }
}

run方法和start方法的区别
run方法是具体的任务方法，start方法是启动方法
调用run方法：run方法作为Thread类的一个普通方法，并没有启动线程
调用start方法：start方法是启动方法，调用它才是真正的开启了一个线程

两种线程创建方式的比较
使用Runnable接口
可以将CPU、代码和数据分开，姓程清晰的模型，也就是说将线程的任务从线程的子类中分离出来，进行了单独的封装，还可以从其他类继承； 保持程序风格的一致性 ； 避免继承的局限，一个类可以实现多个接口。
继承Thread类
不能再从其他类继承； 编写简单，可以直接操纵线程，无需使用Thread。currentThread()（返回当前线程对象）

Thread类的对象才是真正的线程对象

Message与Handler（消息处理机制）

消息队列机制
Looper：轮询器，一个线程可以产生一个Looper对象，由他来管理此线程里的MessageQueue（消息队列）
Handler：构造Handler对象来与Looper沟通，将消息加入到特定的Looper消息队列中，并分发和处理该消息队列中的消息。
Message Queue（消息队列）：用来存放线程放入的消息。
Message：消息对象，Message Queue中存放的对象 ，其包含好几个实例变量

• 主线程创建时，系统会同时创建消息队列对象（Message Queue）和消息轮询器对象（Looper）
• 轮询器（Looper）：作用就是不停的监测消息队列中是否有消息（Message）
• 消息队列中一旦有消息，轮询器会把消息对象传递给消息处理器（Handler），处理器会调用handleMessage方法来处理这条消息，handleMessage方法运行在主线程中，所以可以刷新UI