Android 的 IntentService 与 Service

前言

之前一直用IntentService,Service,而且网上说IntentService比Service要好,好在那里?,工作中遇到关于IntentService的问题,才总结,亡羊补牢为时不晚。

背景:

在启动页上做广告图效果,app 启动时候开启一个IntentService 去下载 包含广告信息的Json串缓存到本地,再次启动app时候,解析上次缓存到本地json串,更新广告ui。
放在IntentService中有两个网络请求来实现信息同步应该可以完美解决,现实情况是同样的代码在Intentservice 中不能缓存广告url到sp中,但是修改为Service就可以正常展示广告,并缓存到sp中。

网上摘抄:

     1. Service不是进程也不是线程他是android的一个组件 ,它和应用程序在同一个进程中。
    
     2. Service不是一个线程,所以我们应该避免在Service里面进行耗时的操作
     3.  每个Handler实例,都会绑定到创建他的线程中(一般是位于主线程), 也就是说Handler对象初始化
          后,就默认与对它初始化的线程的消息队列绑定,因此可以利用Handler所包含的消息队列,制
      定一些操作的顺序。

[问题]

那么为什么我不直接用Thread而要用Service呢?

翻开一些IntentService相关的blog大致有5点疑问

猜想一,线程嵌套,线程A会不会等待B,C线程执行完,停止A线程,即多个嵌套线程执行顺序是否是串行的

线程a{

线程B{. }
线程C{. }

stop线程A
}

代码:

package com.tseng.alldilaog.guess;

public class Threademo {


    static Runnable runnable = null;
    static Thread thread = null;

    public static void main(String[] args) {

        setRun();
        thread = new Thread(new Runnable() {
            @Override
            public void run() {
                Thread threadb = new Thread(runnable, "THREAD_B");
                threadb.start();
                System.out.println(Thread.currentThread().getName() + "  执行时间:");
                thread.stop();
            }
        }, "Thread_A");
        thread.start();

    }

    private static void setRun() {
        runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(5000);
                    System.out.println(Thread.currentThread().getName() + " 猜想会打印");
                } catch (Exception e) {
                    e.printStackTrace();
                }

            }
        };
    }

}

执行结果

Thread_A  执行时间:
THREAD_B 猜想会打印

Process finished with exit code 0

答案:
线程B 和线程A,是不同的线程,在未受到人为干预(线程同步)情况下,A,B 互相不受影响,关闭线程B的宿主A,嵌套Thread B 仍然会执行完毕。

猜想二

IntentService 中的OnIntent( ) 方法内部是执行耗时操作的,是否可以执行【子线程】的操作,2️⃣ 执行子线程操作会进行阻塞线程吗?后面的stopService() 会先于线程执行吗?

package com.tseng.alldilaog.service;

import android.app.IntentService;
import android.content.Intent;
import android.os.Looper;
import android.support.annotation.Nullable;
import android.widget.Toast;

import com.tseng.alldilaog.MyApp;

public class IntentServiceDemo extends IntentService {

    public static String Tag = IntentService.class.getSimpleName();


    public IntentServiceDemo() {
        super(Tag);
    }

    @Override
    protected void onHandleIntent(@Nullable Intent intent) {

        Toast.makeText(MyApp.getmContext(),"弹窗",1000).show();
        System.out.println(Thread.currentThread().getName() + " 当前线程" + getMainLooper()  +" my looper" + Looper.myLooper());

        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                Thread threadb = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            System.out.println(Thread.currentThread().getName() + " 猜想会打印");
                        } catch (Exception e) {
                            e.printStackTrace();
                        }

                    }
                }, "THREAD_B");
                threadb.start();

                System.out.println(Thread.currentThread().getName() + "  执行时间:");
            }
        }, "Thread_A");
        thread.start();


    }


    @Override
    public void onDestroy() {
        super.onDestroy();
        System.out.println(Tag + "  OnDestroy");
    }

    @Override
    public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
        return super.onStartCommand(intent, flags, startId);
    }
}

MainActivity

    @Override
    protected void onResume() {
        super.onResume();
        Intent intent = new Intent(MainActivity.this, IntentServiceDemo.class);
        startService(intent);
        }

答案:

在IntentService的 protected void onHandleIntent(@Nullable Intent intent)的方法中进行线程嵌套 (猜想一代码),结论一致。
只是IntentService 的 ondestroy( )会优先执行。
【注意】:网上所说的可以在 onHandleIntent()方法中做耗时操作。为了保持生命周期的连贯性 ondestroy()在耗时任务完成后调用。建议在onHandleIntent方法中做同步工作。

08-30 14:54:05.511 2709-2709/com.tseng.alldilaog I/System.out: Thread[main,5,main]   looper =Looper (main, tid 1) {a86f274}

08-30 14:54:05.549 2709-2781/com.tseng.alldilaog I/System.out: IntentService[IntentService] 当前线程Looper (main, tid 1) {a86f274}
08-30 14:54:05.570 2709-2783/com.tseng.alldilaog I/System.out: Thread_A  执行时间:
08-30 14:54:05.571 2709-2784/com.tseng.alldilaog I/System.out: THREAD_B 猜想会打印
08-30 14:54:10.574 2709-2709/com.tseng.alldilaog I/System.out: IntentService  OnDestroy

猜想三

子线程中的getMainLooper(),拿到的是子线程的Looper 还是主ui线程的Looper,二 ,getLooper的阻塞指的是二次StartService()时候,才会调用吗?

样例代码:

@Override
protected void onResume() {
    super.onResume();
    Intent intent = new Intent(MainActivity.this, IntentServiceDemo.class);
    startService(intent);
    System.out.println("第二次调用");
    Intent intent2 = new Intent(MainActivity.this,IntentServiceDemo.class);
    startService(intent2);
}

答案:

getMainLooper():当前线程Looper (main, tid 1) {a86f274}

Looper.myLooper() :Looper (IntentService[IntentService], tid 481) {fda1c0c}

关于IntentService()内部原理方面,二次startService() 会以Message 队列方式进行运行,调用两次,执行两次onHandleIntent()方法

输出:

08-30 15:11:40.262 8294-8294/com.tseng.alldilaog I/System.out: Thread[main,5,main]   looper =Looper (main, tid 1) {a86f274}   这句是在Activity的Oncreat()中调用的

08-30 15:11:40.285 8294-8294/com.tseng.alldilaog I/System.out: 第二次调用
08-30 15:11:40.353 8294-8393/com.tseng.alldilaog I/System.out: IntentService[IntentService] 当前线程Looper (main, tid 1) {a86f274} my looperLooper (IntentService[IntentService], tid 493) {105e0a4}
08-30 15:11:40.354 8294-8394/com.tseng.alldilaog I/System.out: Thread_A  执行时间:
08-30 15:11:40.356 8294-8395/com.tseng.alldilaog I/System.out: THREAD_B 猜想会打印

08-30 15:11:45.417 8294-8393/com.tseng.alldilaog I/System.out: IntentService[IntentService] 当前线程Looper (main, tid 1) {a86f274} my looperLooper (IntentService[IntentService], tid 493) {105e0a4}
08-30 15:11:45.424 8294-8742/com.tseng.alldilaog I/System.out: Thread_A  执行时间:
08-30 15:11:45.424 8294-8743/com.tseng.alldilaog I/System.out: THREAD_B 猜想会打印

08-30 15:11:50.427 8294-8294/com.tseng.alldilaog I/System.out: IntentService  OnDestroy

猜想四

Hander是主线程hander还是子线程hander,取决于Looper()所在的线程和Hander初始化的线程。
1.主线程有初始化Handler 不指定Looper(),那hander属于主线程Handler。如果主线程Hander,给的子线程Looper(),那么会是子线程的Handler(),
区分是主线程hander还是子线程Hander,在于是否可以直接操作ui线程的ui元素

答案:

以上猜想是正确的,Handler 具体是子线程的Handler还是主线程的Hander,取决于用的初始化的Looper 是在子线程中初始化,还是主线程中。

Hander hander =new Handler( Lopper) //默认使用的是主线程的Looper(),这也是为什么在子线程
中不能new Handler的原因,需要:

        Looper.prepare();
        ...
        ...
        ...
        Looper.loop();
 

子线程需要和Handler 进行手动绑定

猜想五

HandlerThread 原理是在子线程中,绑定Hander + Looper【消息队列】,默认线程和Handler是不绑定的,为了方便系统提供的方法

这里写图片描述

这里可以是同一线程,多个message,也统一是不同线程的Message,放到消息队列中

延伸:

IntentServive 原理 ,HandlerThread 用法,Handler 是子线程Handler 还是主线程Handler,

总结:

android service 有两种开启方式

1.startservice(),bindService() 开启
2.unstartservice(),unbindService() 反注册

startservice–>onCreat(){ startForeground(1,通知)}

允许创建一个前台服务,普通service默认是后台服务,无交互,运行主线程,而前台服务会在通知栏上展示一个通知图标,当服务
终止后通知图标也会立即消失。

3.bindService(context,serviceConnect,flag) 属于绑定形式开启。服务开启后会通过一个回调serviceconnect进行相互同行,需要
Binder 进行中转。

服务生命周期

startservice会调用 oncreate() onstartcommond(),重复调用会多次执行onstartcommond()
bindService会调用的oncreate()以及serviceConnect()回调。

?如何选择合适开启service方式,一种是于服务有绑定关系,一种是无绑定关系,根据调用服务后是否与服务有交互来选择合适开启方式。

startservice ,bindService后关闭服务同样需要调用两次解绑,startservice()是开启服务,bindservic是绑定服务。

service与thread 区别。

没有区别,service是运行在主线程,对用户是透明的。

引用:
http://www.cnblogs.com/ghj1976/archive/2011/05/06/2038469.html

©️2020 CSDN 皮肤主题: 编程工作室 设计师: CSDN官方博客 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值