杀死Android中的其他进程

我可以通过编程方式结束或终止其他正在运行的进程吗？有人问我的朋友，告诉我应该使用类似信息亭的模式

谁能帮我解决这个问题

---

所有的问候和感谢。

我想你可以试试类似的

android.os.Process.killProcess（android.os.Process.myPid（））

但是如果你想杀死其他进程，你必须拥有root权限（一般来说，你没有这个权限）
试试这段代码

关闭所有进程，但不关闭系统进程

//托多清洁服务

ActivityManager mActivityManager = (ActivityManager) this
        .getSystemService(ACTIVITY_SERVICE);
List<ActivityManager.RunningServiceInfo> rs = mActivityManager
        .getRunningServices(500);

Intent destrIntent;
for (int i = 0; i < rs.size(); i++) {
    ActivityManager.RunningServiceInfo rsi = rs.get(i);

    if (!rsi.service.getClassName().contains("com.android")
            || !rsi.service.getPackageName().contains("com.android")) {

        android.os.Process.sendSignal(rsi.pid,
                android.os.Process.SIGNAL_KILL);
        mActivityManager.killBackgroundProcesses(rsi.service
                .getPackageName());
    }
}

ActivityManager mActivityManager=（ActivityManager）此
.getSystemService（活动和服务）；
列表rs=mActivityManager
.getRunningServices（500）；
意图破坏意图；
对于（int i=0；i
最近，我在调查同样的问题，因为我厌倦了手动关闭谷歌地图应用程序，该应用程序会定期自动打开并在后台运行，并耗尽电池电量

但我不认为Android可以让你杀死任何进程，除了你自己的进程。出于安全目的，这是很好的，但我至少希望它们包含一个应用程序权限，以便在用户允许的情况下，程序能够这样做

我尝试了以下方法，但没有一种有效：


activityManagerObject.KillBackgroundProcess（packageName）
进程。进程（pid）
进程发送信号（pid、进程信号）

一位用户指出，自从安卓2.1以来，这是不可能的。请看这里：

由于安卓操作系统对美国用户也有其他限制，用户被迫接受愚蠢的限制，并减少了对其采取任何行动的权利。我不知道其他移动操作系统的情况，但这正是安卓s***的大好时机。
自从安卓2.2（或更高版本，我不记得了）以来，你只能使用意图杀死你自己的应用程序。要从应用程序中终止另一个进程，您必须拥有根设备，手动解析
ps
命令输出，获取所需的进程ID，执行
su
，将
kill
命令写入此管道，然后开始。我为自己的库编写了这段代码，因此这些方法是分开的，但希望您理解：

    public interface ExecListener {
        void onProcess (String line, int i);
    }

    public static String exec (String input) throws IOException, InterruptedException {
        return exec (input, null);
    }

    public static String exec (String input, ExecListener listener) throws IOException, InterruptedException {

        Process process = Runtime.getRuntime ().exec (input);
        BufferedReader in = new BufferedReader (new InputStreamReader (process.getInputStream ()));

        StringBuilder output = new StringBuilder ();

        int i = 0;
        String line;

        while ((line = in.readLine ()) != null) {

            if (listener == null)
               output.append (line).append ("\n");
            else
               listener.onProcess (line, i);

            ++i;

        }

        in.close ();
        process.waitFor ();

        return output.toString ().trim ();

    }

    public static void execSU (List<String> cmds) throws IOException, InterruptedException {

        Process process = Runtime.getRuntime ().exec ("su");
        DataOutputStream os = new DataOutputStream (process.getOutputStream ());

        for (String cmd : cmds) os.writeBytes (cmd + "\n");

        os.writeBytes ("exit\n");

        os.flush ();
        os.close ();

        process.waitFor ();

    }

    public static void killProcess (String id) throws IOException, InterruptedException {
        return killProcess (new String[] {id});
    }

    public static void killProcess (final String[] ids) throws IOException, InterruptedException {

        final ArrayList<String> procs = new ArrayList<> ();

        exec ("ps", new ExecListener () {

            @Override
            public void onProcess (String line, int i) {

                if (i > 0) {

                    String[] data = Arrays.explode ("\\s+", line);

                    for (String id : ids)
                      if (id.equals (data[8]))
                        procs.add (data[1]);

                }

            }

        });

        if (procs.size () > 0) {

            ArrayList<String> cmds = new ArrayList<> ();
            cmds.add ("kill -9 " + Arrays.implode (" ", procs));

            execSU (cmds);

        }

    }

公共接口执行侦听器{
void onProcess（字符串行，int i）；
}
公共静态字符串执行器（字符串输入）抛出IOException、InterruptedException{
返回exec（输入，空）；
}
公共静态字符串exec（字符串输入，ExecListener侦听器）抛出IOException、InterruptedException{
processprocess=Runtime.getRuntime（）.exec（输入）；
BufferedReader in=新的BufferedReader（新的InputStreamReader（process.getInputStream（））；
StringBuilder输出=新的StringBuilder（）；
int i=0；
弦线；
而（（line=in.readLine（））！=null）{
if（侦听器==null）
output.append（行）.append（“\n”）；
其他的
listener.onProcess（行，i）；
++一,；
}
in.close（）；
process.waitFor（）；
返回output.toString（）.trim（）；
}
公共静态void execSU（列表cmds）引发IOException、InterruptedException{
processprocess=Runtime.getRuntime（）.exec（“su”）；
DataOutputStream os=新的DataOutputStream（process.getOutputStream（））；
对于（字符串cmd:cmds）os.writeBytes（cmd+“\n”）；
os.writeBytes（“退出”）；
os.flush（）；
os.close（）；
process.waitFor（）；
}
公共静态无效进程（字符串id）引发IOException、InterruptedException{
返回killProcess（新字符串[]{id}）；
}
公共静态void killProcess（最终字符串[]id）引发IOException、InterruptedException{
final ArrayList procs=new ArrayList（）；
exec（“ps”，新的ExecListener（）{
@凌驾
公共void onProcess（字符串行，int i）{
如果（i>0）{
String[]data=Arrays.explode（“\\s+”，第行）；
用于（字符串id:ids）
如果（id.equals（数据[8]））
程序添加（数据[1]）；
}
}
});
如果（procs.size（）>0）{
ArrayList cmds=新的ArrayList（）；
cmds.add（“kill-9”+Arrays.infrade（“，procs））；
execSU（cmds）；
}
}
我只是想说清楚，这就是我在根手机上的工作原理（这意味着设备可以使用su命令）：

其中pid是要终止的应用程序的进程id，它应该是一个数字

请注意，这也取决于系统。在一些没有“sh-c”的系统中，它可以工作。在某些系统中，需要在su命令后指定uid：

su uid 

希望能有帮助

David
但是你知道如何使用kiosk模式吗？我想你可以尝试从那里进行研究：对不起，这段代码不起作用，可能只有kill-only进程在后台运行。你的代码中有一个错误。execSU的第一行应该是：processprocess=Runtime.getRuntime（）.exec（“sh-csu”）@大卫你好！谢谢，但奇怪的是，您需要用shell加载命令，因为
su
是在超级用户（su）下加载shell（sh）的命令。或者你的设备根本就没有根。
su uid