Android四大组件-Service(服务)

最新推荐文章于 2022-11-10 15:27:44 发布

tjulxh

最新推荐文章于 2022-11-10 15:27:44 发布

阅读量1.5k

点赞数

分类专栏： Android开发文章标签： android java apache

本文链接：https://blog.csdn.net/tjulxh/article/details/120972315

版权

Android开发专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一.线程

1.1 线程相关概念

程序：为了完成特定任务,用某种语言编写的一组指令集合(一组静态代码)

进程：运行中的程序,系统调度与资源分配的一个独立单位,操作系统会为每个进程
分配一段内存空间!程序的依次动态执行,经历代码的加载,执行, 执行完毕的完整
过程!

线程：比进程更小的执行单元,每个进程可能有多条线程,线程需要放在一个进程中
才能执行,线程由程序负责管理,而进程则由系统进行调度!

多线程的理解：并行执行多个条指令,将CPU时间片按照调度算法分配给各个线程,
实际上是分时执行的,只是这个切换的时间很短,用户感觉到"同时"而已!

1.2线程的生命周期

1.3创建线程的三种方法

1.继承Thread类

public class MyThread extends Thread {
    @Override
    public void run() {
        doSomething();
    }

    public void doSomething() {
        System.out.println("我是线程中的一个方法");
    }
}


------------------------------------------
public class MythreadTest {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();//开启一个线程中的方法
        //以下的方法可以与上边的线程并发执行
        doSomething();
    }

    private static void doSomething(){

    }
}

2.实现Runable接口

public class RunableThread implements Runnable{
    @Override
    public void run() {
        doSomething();
    }

    private void doSomething(){
        System.out.println("我是一个线程方法");
    }
}

------------------------------------------
public class MyRunableThreadTest {
    public static void main(String[] args) {
        Runnable runnable = new RunableThread();
        Thread thread = new Thread(runnable);
        thread.start();//开启一个线程方法
        //一下线程可与上面线程并发执行
        doSomething();
    }
    private static void doSomething(){
        System.out.println("这是一个并行执行方法");

    }
}

3.实现Callable接口和Future创建线程

public class CallableThread implements Callable<String> {
    @Override
    public String call() throws Exception {
        doSomething();
        return "需要返回的值";
    }

    private void doSomething(){
        System.out.println("这是线程中的方法");
    }
}
-------------------------------------------------------
public class CallableThreadTest {
    public static void main(String[] args) {
        Callable<String> callable = new CallableThread();
        FutureTask<String> futureTask = new FutureTask<String>(callable);
        Thread thread = new Thread(futureTask);
        thread.start();//开启一个线程方法
        //以下方法可以和上边线程并发执行
        doSomething();
    }

    private static void doSomething(){
        System.out.println("这是另一个线程中方法");
    }
}

1.4 Service与Thread线程的区别

其实他们两者并没有太大的关系,不过有很多朋友经常把这两个混淆了! Thread是线程,程
序执行的最小单元,分配CPU的基本单位! 而Service则是Android提供一个允许长时间留
驻后台的一个组件,最常见的用法就是做轮询操作!或者想在后台做一些事情,比如后台下
载更新! 记得别把这两个概念混淆!

二、Service的生命周期

生命周期函数解析:
1)onCreate():当Service第一次被创建后立即回调该方法,该方法在整个生命周期 中只会调用一
次!
2)onDestory():当Service被关闭时会回调该方法,该方法只会回调一次!
3)onStartCommand(intent,flag,startId):早期版本是onStart(intent,startId), 当客
户端调用startService(Intent)方法时会回调,可多次调用StartService方法, 但不会再创建新
的Service对象,而是继续复用前面产生的Service对象,但会继续回调 onStartCommand()方法!
IBinder onOnbind(intent):该方法是Service都必须实现的方法,该方法会返回一个 IBinder
对象,app通过该对象与Service组件进行通信!
4)onUnbind(intent):当该Service上绑定的所有客户端都断开时会回调该方法!

2.1 service启动方式

1)StartService()启动Service
2)BindService()启动Service
PS:还有一种,就是启动Service后,绑定Service!

2.1.1 StartService启动Service

1首次启动会创建一个Service实例,依次调用onCreate()和onStartCommand()方法,此时
Service 进入运行状态,如果再次调用StartService启动Service,将不会再创建新的Service
对象, 系统会直接复用前面创建的Service对象,调用它的onStartCommand()方法!

2但这样的Service与它的调用者无必然的联系,就是说当调用者结束了自己的生命周期, 但是只要
不调用stopService,那么Service还是会继续运行的!

3无论启动了多少次Service,只需调用一次StopService即可停掉Service

public class MyService1 extends Service {
    private final String TAG = "service";

    //必须要实现的方法
    @Override
    public IBinder onBind(Intent intent) {
        Log.e(TAG, "onBind方法被调用!");
        return null;
    }

    //Service被创建时调用
    @Override
    public void onCreate() {
        Log.e(TAG, "onCreate方法被调用!");
        super.onCreate();
    }

    //Service被启动时调用
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.e(TAG, "onStartCommand方法被调用!");
        return super.onStartCommand(intent, flags, startId);
    }

    //Service被关闭之前回调
    @Override
    public void onDestroy() {
        Log.e(TAG, "onDestory方法被调用!");
        super.onDestroy();
    }
}

public class ServiceActivity extends AppCompatActivity {
    private Button start;
    private Button stop;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.service_layout);

        start = (Button) findViewById(R.id.btnstart);
        stop = (Button) findViewById(R.id.btnstop);

        final Intent intent = new Intent(ServiceActivity.this, MyService1.class);
        start.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                startService(intent);
            }
        });

        stop.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                stopService(intent);
            }
        });
    }
}

service_layout.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <Button
        android:id="@+id/btnstart"
        android:layout_width="0dp"
        android:layout_weight="1"
        android:layout_height="wrap_content"
        android:text="开始服务"/>

    <Button
        android:id="@+id/btnstop"
        android:layout_width="0dp"
        android:layout_weight="1"
        android:layout_height="wrap_content"
        android:text="停止服务"/>

</LinearLayout>

2.1.2 BindService启动Service

1当首次使用bindService绑定一个Service时,系统会实例化一个Service实例,并调用其
onCreate()和onBind()方法,然后调用者就可以通过IBinder和Service进行交互了,此后如果
再次使用bindService绑定Service,系统不会创建新的Sevice实例,也不会再调用onBind()方
法,只会直接把IBinder对象传递给其他后来增加的客户端!

2如果我们解除与服务的绑定,只需调用unbindService(),此时onUnbind和onDestory方法将
会被调用!这是一个客户端的情况,假如是多个客户端绑定同一个Service的话,情况如下当一个客
户完成和service之间的互动后,它调用 unbindService() 方法来解除绑定。当所有的客户端
都和service解除绑定后,系统会销毁service。(除非service也被startService()方法开
启

3另外,和上面那张情况不同,bindService模式下的Service是与调用者相互关联的,可以理解为
"一条绳子上的蚂蚱",要死一起死,在bindService后,一旦调用者销毁,那么Service也立即终
止!

通过BindService调用Service时调用的Context的bindService的解析
bindService(Intent Service,ServiceConnection conn,int flags)

service:通过该intent指定要启动的Service

conn:ServiceConnection对象,用户监听访问者与Service间的连接情况, 连接成功回调该对
象中的onServiceConnected(ComponentName,IBinder)方法; 如果Service所在的宿主由
于异常终止或者其他原因终止,导致Service与访问者间断开连接时调用
onServiceDisconnected(CompanentName)方法,主动通过unBindService() 方法断开并
不会调用上述方法!
flags:指定绑定时是否自动创建Service(如果Service还未创建), 参数可以是0(不自动创
建),BIND_AUTO_CREATE(自动创建)

2.1.3StartService启动Service后bindService绑定

1 如果Service已经由某个客户端通过StartService()启动,接下来由其他客户端再调用
bindService()绑定到该Service后调用unbindService()解除绑定最后在调用
bindService()绑定到Service的话,此时所触发的生命周期方法如下:
2 onCreate( )->onStartCommand( )->onBind( )->onUnbind( )->onRebind( )
3 PS:前提是:onUnbind()方法返回true!!! 这里或许部分读者有疑惑了,调用了unbindService
后Service不是应该调用 onDistory()方法么!其实这是因为这个Service是由我们的
StartService来启动的 ,所以你调用onUnbind()方法取消绑定,Service也是不会终止的!
4 得出的结论: 假如我们使用bindService来绑定一个启动的Service,注意是已经启动的
Service!!! 系统只是将Service的内部IBinder对象传递给Activity,并不会将Service的生
命周期与Activity绑定,因此调用unBindService( )方法取消绑定时,Service也不会被销
毁!

public class MyService2 extends Service {
    private final String TAG = "service";
    private int count;
    private boolean quit;

    //定义onBinder方法所返回的对象
    private MyBinder binder = new MyBinder();

    public class MyBinder extends Binder {
        public int getCount() {
            return count;
        }
    }

    //必须实现的方法,绑定改Service时回调该方法
    @Override
    public IBinder onBind(Intent intent) {
        Log.e(TAG, "onBind方法被调用!");
        return binder;
    }

    //Service被创建时回调
    @Override
    public void onCreate() {
        super.onCreate();
        Log.e(TAG, "onCreate方法被调用!");
        //创建一个线程动态地修改count的值
        new Thread() {
            public void run() {
                while (!quit) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    count++;
                    Log.e(TAG, "count = " + count);
                }
            }
        }.start();
    }

    //Service断开连接时回调
    @Override
    public boolean onUnbind(Intent intent) {
        Log.e(TAG, "onUnbind方法被调用!");
        return true;
    }

    //Service被关闭前回调
    @Override
    public void onDestroy() {
        super.onDestroy();
        this.quit = true;
        Log.e(TAG, "onDestroyed方法被调用!");
    }

    @Override
    public void onRebind(Intent intent) {
        Log.e(TAG, "onRebind方法被调用!");
        super.onRebind(intent);
    }
}

public class Service2Activity extends AppCompatActivity {

    private Button btnbind;
    private Button btncancel;
    private Button btnstatus;
    //保持所启动的Service的IBinder对象,同时定义一个ServiceConnection对象
    private MyService2.MyBinder binder;

    private ServiceConnection conn = new ServiceConnection() {

        //Activity与Service断开连接时回调该方法
        @Override
        public void onServiceDisconnected(ComponentName name) {
            Log.e("service", " ------Service DisConnected-------");
        }

        //Activity与Service连接成功时回调该方法
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            Log.e("service", " ------Service Connected------ - ");
            binder = (MyService2.MyBinder) service;
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.service2_layout);
        btnbind = (Button) findViewById(R.id.btnbind);
        btncancel = (Button) findViewById(R.id.btncancel);
        btnstatus = (Button) findViewById(R.id.btnstatus);
        final Intent intent = new Intent(Service2Activity.this, MyService2.class);

        btnbind.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //绑定service
                bindService(intent, conn, Service.BIND_AUTO_CREATE);
            }
        });

        btncancel.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //解除service绑定
                unbindService(conn);
            }
        });

        btnstatus.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Toast.makeText(getApplicationContext(), "Service的count的值为:"
                        + binder.getCount(), Toast.LENGTH_SHORT).show();
            }
        });
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        unbindService(conn); // 销毁Activity时需要解绑Service
    }
}

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingTop="15dp"
    android:orientation="vertical">

    <Button
        android:id="@+id/btnbind"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="绑定Service" />

    <Button
        android:id="@+id/btncancel"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="15dp"
        android:text="解绑Service" />

    <Button
        android:id="@+id/btnstatus"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="15dp"
        android:text="获取Service状态" />

</LinearLayout>

tjulxh

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Android四大组件-Service(服务)

一.线程1.1 线程相关概念程序：为了完成特定任务,用某种语言编写的一组指令集合(一组静态代码) 进程：运行中的程序,系统调度与资源分配的一个独立单位,操作系统会为每个进程分配一段内存空间!程序的依次动态执行,经历代码的加载,执行, 执行完毕的完整过程! 线程：比进程更小的执行单元,每个进程可能有多条线程,线程需要放在一个进程中才能执行,线程由程序负责管理,而进程则由系统进行调度! 多线程的理解：并行执行多个条指令,将CPU时间片按照调度算法分配给各个线程,实际上...
复制链接

扫一扫

专栏目录