安卓之service学习总结

最新推荐文章于 2022-05-03 15:06:10 发布

原创最新推荐文章于 2022-05-03 15:06:10 发布 · 1k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Android #多线程

android 专栏收录该内容

18 篇文章

订阅专栏

本文详细解析了Android中Service的启动流程，包括startService与bindService的区别及应用场景，并介绍了如何在Service中使用多线程进行延时操作和消息循环。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Service启动流程

context.startService() -> onCreate() -> onStart() -> Service running -> context.stopService() -> onDestroy() -> Service stop

如果Service还没有运行，则android先调用onCreate()，然后调用onStart()；

如果Service已经运行，则只调用onStart()，所以一个Service的onStart方法可能会重复调用多次。

如果stopService的时候会直接onDestroy，如果是调用者自己直接退出而没有调用stopService的话，Service会一直在后台运行，该Service的调用者再启动起来后可以通过stopService关闭Service。

所以调用startService的生命周期为：onCreate --> onStart (可多次调用) --> onDestroy

	Intent myIntent = new Intent(FileActivity.this, MyService.class);
		startService(myIntent);// 发送Intent启动Service

stopService(new Intent(FileActivity.this, MyService.class));

和activity还有广播一样，service也需要注册一个，在xml文件中：

  </service>
        <service android:name="com.example.widgetflashlight.MyService" >

在service内，如果需要进行一些延时类的操作，如隔几秒之后检查一次系统的状态，或者发送广播。则需要新建一个线程。方法有

new一个Runnable。

private Runnable mTasks = new Runnable() {
   public void run() {
                }
};

或者new一个Thread

  new Thread(){
                        public void run(){
						}
                          }.start();

还有一个即写即用的方法：

new Thread(new Runnable() {
			boolean flag = true;
			public void run() {
				Looper.prepare();
				
				while (flag) {
					
					new Thread(new Runnable() {
						public void run() {
							Looper.prepare();
							}
						}
					}).start();

这是一个嵌套。是从实际工程中copy出来的（为了清楚删除了一些处理代码）。关于Looper在下面的叙述，Looper.prepare()方法

如果想让该线程具有消息队列和消息循环，需要在线程中首先调用Looper.prepare()来创建消息队列，然后调用Looper.loop()进入消息循环。

在实际开发中一个多线程的操作很少使用Thread类，而是通过Runnable接口完成。

在程序开发中只要是多线程肯定永远以实现Runnable接口为主，因为实现Runnable接口相比继承Thread类有如下好处：

避免点继承的局限，一个类可以继承多个接口。
适合于资源的共享

当使用多线程时一般需要和handler一起使用：关于handler
Handler可以分发Message对象和Runnable对象到主线程中, 每个Handler实例,都会绑定到创建他的线程中(一般是位于主线程),
它有两个作用: (1): 安排消息或Runnable 在某个主线程中某个地方执行, (2)安排一个动作在不同的线程中执行

Handler中分发消息的一些方法
post(Runnable)
removeCallbacks(Runnable)
postAtTime(Runnable,long)
postDelayed(Runnable long)
sendEmptyMessage(int)
sendMessage(Message)
sendMessageAtTime(Message,long)
sendMessageDelayed(Message,long)

Delayed()方法是延迟一定时间后，将Runnable添加入队列

AtTime()方法是定时将Runnable添加入队列

以上post类方法允许你排列一个Runnable对象到主线程队列中,

removeCallbacks()方法则是将Runnable移出队列，如程序需要结束时。

sendMessage类方法, 允许你安排一个带数据的Message对象到队列中，等待更新.

private void sendMsg (int what) {//发送消息的方法
Message msg = new Message();
msg.what = what;
handler.sendMessage(msg);
}

在activity中处理消息所用的函数方法：

private class Check extends Handler {
		public CheckWebserver_Handler(Looper mainLooper) {
			super(mainLooper);
			// TODO Auto-generated constructor stub
		}
		public void handleMessage(Message msg) {
			switch (msg.what) {
			case 0: 
				// 进行后续处理 
			case 1:			 
			}
		}
	}

avtivity中调用处理消息方法：

Looper mainLooper = Looper.getMainLooper();
Check  handler = new CheckWebserver_Handler(mainLooper);
		new NetCheckWebServer(handler);

关于looper和handler这些：

Message：消息，其中包含了消息ID，消息处理对象以及处理的数据等，由MessageQueue统一列队，终由Handler处理。

Handler：处理者，负责Message的发送及处理。使用Handler时，需要实现handleMessage(Message msg)方法来对特定的Message进行处理，例如更新UI等。

MessageQueue：消息队列，用来存放Handler发送过来的消息，并按照FIFO规则执行。当然，存放Message并非实际意义的保存，而是将Message以链表的方式串联起来的，等待Looper的抽取。

Looper：消息泵，不断地从MessageQueue中抽取Message执行。因此，一个MessageQueue需要一个Looper。

Thread：线程，负责调度整个消息循环，即消息循环的执行场所。

除此之外还有一种service为bindservice()，它和普通的service之间的区别是

BindService中使用bindService()方法来绑定服务，调用者和绑定者绑在一起，调用者一旦退出服务也就终止了【onCreate()->onBind()->onUnbind()->onDestroy()】。

我们在什么情况下要使用这种service呢？

也就是我们需要获得service这个对象，并且需要调用service内的方法的时候，用这种service再合适不过了。

由于没有示例代码，所以从网上借鉴了一份哈。

public class LocalServiceActivity extends Activity {
    /** Called when the activity is first created. */
    private MyService myService;
 
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
 
        Intent intent = new Intent(this, MyService.class);
        bindService(intent, connection, Context.BIND_AUTO_CREATE);
    }
 
    private ServiceConnection connection = new ServiceConnection() {
 
        @Override
        public void onServiceDisconnected(ComponentName name) {
            myService = null;
        }
 
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            myService = ((MyService.MyBinder) service).getService();
            System.out.println("Service连接成功");
            // 执行Service内部自己的方法
            myService.excute();
        }
    };
 
    protected void onDestroy() {
        super.onDestroy();
        unbindService(connection);
    };
}

bindservice：

public class MyService extends Service {
    private final IBinder binder = new MyBinder();
 
    @Override
    public IBinder onBind(Intent intent) {
        return binder;
    }
 
    public class MyBinder extends Binder {
        MyService getService() {
            return MyService.this;
        }
    }
 
    public void excute() {
        System.out.println("通过Binder得到Service的引用来调用Service内部的方法");
    }
 
    @Override
    public void onDestroy() {
        // 当调用者退出(即使没有调用unbindService)或者主动停止服务时会调用
        super.onDestroy();
    }
 
    @Override
    public boolean onUnbind(Intent intent) {
        // 当调用者退出(即使没有调用unbindService)或者主动停止服务时会调用
        System.out.println("调用者退出了");
        return super.onUnbind(intent);
    }
}