保证service服务不容易被杀死的几种方式思路和高级使用

最新推荐文章于 2024-04-28 18:16:24 发布

世界流浪者

最新推荐文章于 2024-04-28 18:16:24 发布

阅读量1.1k

点赞数 2

分类专栏：数据共享与数据传递文章标签：杀不死服务流氓服务流氓线程流氓软件服务重启

本文链接：https://blog.csdn.net/qq_35681180/article/details/53861455

版权

数据共享与数据传递专栏收录该内容

10 篇文章 0 订阅

订阅专栏

说道服务不被杀死说白了分两种情况，一种是永远在执行，不执行ondestory,还有一种方法就是在销毁后重新执行oncreae方法，重新启动，相比而言，第一种基本上时候够呛了，现在的清理软件的优先级非常的高，所以，，，你懂得，你基本上无法创建一个永远不死的，但是可以重生啊！

下边上干货：

1，通过service中的onstartCommand方法，他其中有一个参数是flag,他有四种标志，分别为：

START_STICKY：重启服务，如果没有传递给他一个intent，那么intent为null,

START_NOT_STICKY:如果不进行传递intent，将不会启动，所以不会收到null的intent.

START_REDELIVER_INTENT:重启后将重新的intent传递过来。

START_STICKY_COMPATIBILITY是START_STICKY的兼容版本，不保证一定会重启，所以建议使用第一个标志，

在使用的时候将onstartCommand方法分局不同的需求返回不同的标志即可，首先第一个标志。

2，通过在service中在自己的ondestory方法中，启动oncreate方法即可，这样也是非常简单的

3，通过更改优先级的方式，在清单文件中，将优先级更改为1000，应该就差不多了，在清理内存的时候，优先级越高的越不容易被杀死。

4，通过发送广播，在服务中，当服务销毁的时候发送条广播，广播接收器接收到广播的时候，重新启动服务

5，创建定时器，通过定时启动任务，每隔一定时间重新启动一次服务即可

6，通过将service更改为前台服务也可以避免被杀死

其实方法还有很多，只要保证在服务被杀死之前再通过一定的手段让服务重启即可达到目的。

在这里，我个人建议使用双进程来完成，思路是：创建两个进程，每隔进程相互判断并传递消息，一旦有一个死亡，另一个马上启动治疗模式，将其重生，大家如果细心地就能发现，你手机中的软件，如微信等，都是通过类似这种方式实现的。这样高大上啊：

下面本人将代码贴出，并附上详细的备注：

先创建aidl:(不懂得先学习aidl的使用)

<span style="font-size:14px;">package com.lzg.strongservice.service;  
interface StrongService{  
    void startService();  
    void stopService();  
}</span>

创建服务1：通过服务1，来对服务2进行跨进程操作。

//创建服务1，
public class Service1 extends Service {  
//handler用于接收消息
    private Handler handler = new Handler() {  
        public void handleMessage(android.os.Message msg) {  
            switch (msg.what) {  
            case 1:  
//当收到发送的消息是，启动服务2.
                startService2();  
                break;  
  
            default:  
                break;  
            }  
  
        };  
    };  
  
    /** 
     * 使用aidl 启动Service2 
这是aidl接口实例，接口中定义两个方法，一个是停止服务的方法，一个是开始服务的方法。
     */  
    private StrongService startS2 = new StrongService.Stub() {  
        @Override  
        public void stopService() throws RemoteException {  
当调用停止服务时，停止服务2，
            Intent i = new Intent(getBaseContext(), Service2.class);  
            getBaseContext().stopService(i);  
        }  
  
        @Override  
        public void startService() throws RemoteException { 
//当调用启动服务时，启动服务2. 
            Intent i = new Intent(getBaseContext(), Service2.class);  
            getBaseContext().startService(i);  
        }  
    };  
  
    /** 
     * 在内存紧张的时候，系统回收内存时，会回调OnTrimMemory， 重写onTrimMemory当系统清理内存时从新启动Service2 
     */  
    @Override  
    public void onTrimMemory(int level) {  
        /* 
         * 启动service2 

         */  
        startService2();  
  
    }  
  
    @Override  
    public void onCreate() {  
        Toast.makeText(Service1.this, "Service1 正在启动...", Toast.LENGTH_SHORT)  
                .show();  
//在启动服务1的时候，将服务2也启动，并监听服务2
        startService2();  
        /* 
         * 此线程用监听Service2的状态 
         */  
        new Thread() {  
            public void run() {  
                while (true) {  
//判断服务2是否已经启动，如果没有，则发送一个消息给handler.
                    boolean isRun = Utils.isServiceWork(Service1.this,  
                            "com.lzg.strongservice.service.Service2");  
                    if (!isRun) {  
                        Message msg = Message.obtain();  
                        msg.what = 1;  
                        handler.sendMessage(msg);  
                    }  
                    try {  
                        Thread.sleep(1);  
                    } catch (InterruptedException e) {  
                        // TODO Auto-generated catch block  
                        e.printStackTrace();  
                    }  
                }  
            };  
        }.start();  
    }  
  
    /** 
     * 判断Service2是否还在运行，如果不是则启动Service2 
     */  
    private void startService2() {  
        boolean isRun = Utils.isServiceWork(Service1.this,  
                "com.lzg.strongservice.service.Service2");  
        if (isRun == false) {  
            try {  
                startS2.startService();  
            } catch (RemoteException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
  
    @Override  
    public int onStartCommand(Intent intent, int flags, int startId) {  
//这个方法就是使用了重器标志
        return START_STICKY;  
    }  
  
    @Override  
    public IBinder onBind(Intent intent) {  
        return (IBinder) startS2;  
    }  
}

创建服务2，方法和服务1类似，达到相互控制监听的作用（注释只写了一份，意思相同）：

public class Service2 extends Service {  
  
    private Handler handler = new Handler() {  
        public void handleMessage(android.os.Message msg) {  
            switch (msg.what) {  
            case 1:  
                startService1();  
                break;  
  
            default:  
                break;  
            }  
  
        };  
    };  
  
    /** 
     * 使用aidl 启动Service1 
     */  
    private StrongService startS1 = new StrongService.Stub() {  
  
        @Override  
        public void stopService() throws RemoteException {  
            Intent i = new Intent(getBaseContext(), Service1.class);  
            getBaseContext().stopService(i);  
        }  
  
        @Override  
        public void startService() throws RemoteException {  
            Intent i = new Intent(getBaseContext(), Service1.class);  
            getBaseContext().startService(i);  
  
        }  
    };  
  
    /** 
     * 在内存紧张的时候，系统回收内存时，会回调OnTrimMemory， 重写onTrimMemory当系统清理内存时从新启动Service1 
     */  
    @Override  
    public void onTrimMemory(int level) {  
        startService1();  
    }  
  
    @SuppressLint("NewApi")  
    public void onCreate() {  
  
        Toast.makeText(Service2.this, "Service2 启动中...", Toast.LENGTH_SHORT)  
                .show();  
        startService1();  
        /* 
         * 此线程用监听Service2的状态 
         */  
        new Thread() {  
            public void run() {  
                while (true) {  
                    boolean isRun = Utils.isServiceWork(Service2.this,  
                            "com.lzg.strongservice.service.Service1");  
                    if (!isRun) {  
                        Message msg = Message.obtain();  
                        msg.what = 1;  
                        handler.sendMessage(msg);  
                    }  
                    try {  
                        Thread.sleep(1);  
                    } catch (InterruptedException e) {  
                        e.printStackTrace();  
                    }  
                }  
            };  
        }.start();  
    }  
  
    /** 
     * 判断Service1是否还在运行，如果不是则启动Service1 
     */  
    private void startService1() {  
        boolean isRun = Utils.isServiceWork(Service2.this,  
                "com.lzg.strongservice.service.Service1");  
        if (isRun == false) {  
            try {  
                startS1.startService();  
            } catch (RemoteException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
  
    @Override  
    public int onStartCommand(Intent intent, int flags, int startId) {  
        return START_STICKY;  
    }  
  
    @Override  
    public IBinder onBind(Intent intent) {  
        return (IBinder) startS1;  
    }  
  
}</span></strong>