Android多进程理解一

一、Java进程和线程

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

独立性（每个进程都有自己独立私有的一块内存空间）、动态性、并发性（多个进程可在单处理器上并发执行）

并发是指在同一时间点只能有一条指令执行，但多个进程指令被快速轮换执行，使得在宏观上具有多个进程同时执行的效果。

并行指在同一时间点，有多条指令在多个处理器上同时执行

线程包含在进程中。一个进程可以包含多个线程。

不同的进程使用不同的内存空间，而线程共享父进程的资源。

线程不拥有系统资源，但是有自己的堆栈、自己的局部变量和自己的计数器。

线程由进程负责调度。而进程由操作系统进行调度。

二、线程创建方法

1.继承Thread类创建线程类

2.实现Runnable接口创建线程类

3.使用Callable和Future创建线程。（可以异步返回值）

public class CallableAndFuture {
    public static void main(String[] args) {
        Callable<Integer> callable = new Callable<Integer>() {
            public Integer call() throws Exception {
                return new Random().nextInt(100);
            }
        };
        FutureTask<Integer> future = new FutureTask<Integer>(callable);
        new Thread(future).start();
        try {
            Thread.sleep(5000);// 可能做一些事情
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

三、线程状态和调度

new、runnable、running、blocked、dead

join()方法。一个线程A中调用另一个线程B的join方法，线程A将会等待线程B执行完毕后再执行

setDaemon()方法。设置进程为守护进程

yield()。线程转入就绪状态。让出CPU执行权给同等级的线程，如果没有相同级别的线程在等待CPU的执行权，则该线程继续执行。

四、Java进程、线程通讯

进程间通信包扣：管道、socket、共享内存、信号量、消息队列、信号。

线程间通信主要用于线程同步，没有数据交互机制：锁机制、信号量、信号。

五、Android进程分类

前台进程、可见进程、服务进程、后台进程、空进程

Android创建多进程，在AndroidManifest.xml的声明四大组件的标签中增加”android:process”属性即可。

私有进程的名称前面有冒号，全局进程的名称前面没有冒号

私有进程
<service android:name=".MusicService"   
           android:process=":musicservice"/>
全局进程
<service android:name=".MusicService"   
           android:process="com.demo.test.service"/>

开启多进程之后，需要注意以下问题。

1. application的多次重建

2. 内存隔离问题

3. 文件共享问题

六、Android进程间通信IPC

1. Bundle-Intent：

startActivity(new Intent(...).putExtra("data",bundle));

2. 文件共享：利用多进程同时读写同个外部文件达到是数据交互的目的。读写文件可能效率较低。这一用xml、文本、序列化对象等等

3. SP：通过读取SP，进行数据通信。这是一个轻量级的文件共享的方案，底层也是用xml实现的，系统对它的读写有一定的缓存（缓存在内存中），但是在多进程模式下，系统对它的读写是不可靠的，高并发下可能发生数据丢失。

4. Messenger：在不同的进程之间传递Messager对象。轻量级的AIDL

5. AIDL。基本原理是binder机制。

6. ContentProvider。使用共享内存的基本原理。

七、Andoroid线程间通信

1. Handler机制

  override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        ButterKnife.bind(this)
/*        var value = intent.getIntExtra("key", 0)
        Log.i("------------>", value.toString())*/

        crateNewThread()
    }

    var handler = object : Handler() {
        override fun handleMessage(msg: Message?) {
            super.handleMessage(msg)
            when(msg?.what) {
                1 -> {
                    Log.i("----------->", msg.obj.toString())
                }
                else ->{

                }
            }
        }

    }

    private fun crateNewThread() {
        Thread(object : Runnable{
            override fun run() {
                var message = Message()
                message.what = 1
                message.obj = "Handler 通信"
                handler.sendMessage(message)
            }
        }).start()
    }


    override fun onDestroy() {
        handler.removeCallbacksAndMessages(null)
        super.onDestroy()

    }

2. runOnUiThread 方法

override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        ButterKnife.bind(this)
/*        var value = intent.getIntExtra("key", 0)
        Log.i("------------>", value.toString())*/

        crateNewThread()
    }

    private fun crateNewThread() {
        Thread(object : Runnable {
            override fun run() {
                for(i in 1..3) {//为了练习kotlin for循环 没其他意思
                    sleep(1000)
                }
                runOnUiThread( object : Runnable {
                    override fun run() {
                        tv_main_news_tab.setText("通过RunOnUI 调用")
                    }
                })
            }
        }).start()
    }

3. View.post(Runnable r)

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        ButterKnife.bind(this)
/*        var value = intent.getIntExtra("key", 0)
        Log.i("------------>", value.toString())*/

        crateNewThread()
    }

    private fun crateNewThread() {
        Thread(object : Runnable {
            override fun run() {
                for(i in 1..3) {//为了练习kotlin for循环 没其他意思
                    sleep(1000)
                }
                tv_main_news_tab.post( object : Runnable {
                    override fun run() {
                        tv_main_news_tab.setText("通过RunOnUI 调用")
                    }
                })
            }
        }).start()
    }

4. AsyncTask

  override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        ButterKnife.bind(this)
/*        var value = intent.getIntExtra("key", 0)
        Log.i("------------>", value.toString())*/

        /*crateNewThread()*/

        doAsyncTask()
    }

    private fun doAsyncTask() {
        MyAsyncTask().execute()
    }

     private class MyAsyncTask : AsyncTask<String, Int, String>() {

         override fun onPreExecute() {
             super.onPreExecute()
         }

         override fun doInBackground(vararg params: String?): String {
             for ( i in 1..100) {
                publishProgress(i)
                 sleep(1000)
             }
             return "AsyncTask 已完成"
         }

         override fun onPostExecute(result: String?) {
             super.onPostExecute(result)
             CommonToast.showShort(result.toString())
         }

         override fun onProgressUpdate(vararg values: Int?) {
             super.onProgressUpdate(*values)
             CommonToast.showShort(values.get(0).toString())
         }

     }