Java 启动windows服务、进程，查看某一进程、服务的cpu使用量

最新推荐文章于 2021-02-16 14:41:26 发布
最新推荐文章于 2021-02-16 14:41:26 发布
阅读量106 收藏
点赞数
文章标签： java 操作系统 runtime
原文链接：http://www.cnblogs.com/mituonline/p/4449535.html
版权

　　这几天在做一个模块，使用Java关闭重启windows server 2008上的服务。开始使用的是j-interop。后来leader说，这玩意不行。ms已经去掉了administrator的特权，要使用这玩意就需要用setacl.exe对注册表修改，这exe包，打不开，看不到里面的东西，用起来心慌慌的。

　　后面么，发现当你一超级管理员登陆时，windows上打开的cmd能直接运行关闭启动服务的命令。就来个曲线救国吧，好在不要求远程启动服务，不然又是一番好忙。

　　废话到此结束。

　　前提条件是，你随意打开cmd，上面显示的是“管理员”，如下图所示，否则，还是有些功能不能实现。

       

　　 代码如下：

public class WmiServiceUtils {
    public static final Logger logger = LoggerFactory.getLogger(WmiServiceUtils.class);

    private static List<Map<String, Object>> getAllResult(String[] cmdStr, int flag) throws IOException {
        List<Map<String, Object>> list = new ArrayList<>();
        Integer index = 1;
        Process p = null;
        String str = null;
        String[] arrStr = new String[2];
        Map<String, Object> map = new HashMap<String, Object>();
        InputStreamReader isr = null;
        BufferedReader br = null;
        try {
            p = Runtime.getRuntime().exec(cmdStr);
            isr = new InputStreamReader(p.getInputStream());
            br = new BufferedReader(isr);
            while ((str = br.readLine()) != null) {
                if (StringUtil.isNotEmpty(str)) {
                    if (index % flag == 0) {
                        list.add(map);
                        map = new HashMap<String, Object>();
                    }
                    arrStr = str.split("=");
                    str = str.endsWith("=") ? "" : arrStr[1];
                    map.put(arrStr[0], str);
                    index++;
                }
            }
        } catch (IOException e) {
            logger.error("获取进程的所有信息失败！", e);
            throw e;
        } catch (Exception e) {
            logger.error("获取执行结果失败！", e);
            throw e;
        } finally {
            try {
                if (br != null) {
                }
                br.close();
                if (isr != null) {
                    isr.close();
                }
            } catch (IOException e) {
                logger.error("", e);
            }
            if (p != null) {
                p.destroy();
            }
        }
        return list;
    }

    @SuppressWarnings("unused")
    private static String parse2Time(long milliseconds) {
        if (milliseconds == 0) {
            return "0秒";
        }
        if (milliseconds / 1000 == 0) {
            return "0." + milliseconds + "秒";
        }
        milliseconds = milliseconds / 1000;
        long day = milliseconds / (24 * 3600);
        milliseconds = milliseconds % (24 * 3600);
        if (milliseconds == 0) {
            return day + "天";
        }
        long hour = milliseconds / (3600);
        milliseconds = milliseconds % (3600);
        if (milliseconds == 0) {
            return day + "天" + hour + "小时";
        }
        long minute = milliseconds / (60);
        milliseconds = milliseconds % (60);
        if (milliseconds == 0) {
            return day + "天 " + hour + "小时 " + minute + "分钟";
        } else {
            return day + "天 " + hour + "小时 " + minute + "分钟 " + milliseconds + "秒";
        }
    }

    private static Map<String, Object> printStream(InputStream input) throws IOException { //InputStream input  final Process proc
        InputStreamReader isr = new InputStreamReader(input); //proc.getInputStream()
        BufferedReader br = new BufferedReader(isr);
        Map<String, Object> map = new HashMap<String, Object>();
        String str = null;
        String[] arrStr = null;
        try {
            while ((str = br.readLine()) != null) {
                if (StringUtil.isNotEmpty(str)) {
                    if (str.contains("=")) {
                        arrStr = str.split("=");
                        str = str.endsWith("=") ? "" : arrStr[1];
                        map.put(arrStr[0], str);
                    } else {
                        map.put(str, null);
                    }
                }
            }
        } catch (IOException e) {
            logger.error("关闭文件流失败！", e);
            throw e;
        } finally {
            try {
                if (br != null) {
                    br.close();
                }
                if (isr != null) {
                    isr.close();
                }
                if (input != null) {
                    input.close();
                }
            } catch (IOException e) {
                logger.error("关闭文件流失败！", e);
                throw e;
            }
        }
        return map;
    }

    private static String printErrorStream(InputStream input) throws IOException {
        InputStreamReader reader = new InputStreamReader(input);
        BufferedReader br = new BufferedReader(reader);
        String msg = "";
        String str = "";
        try {
            while ((str = br.readLine()) != null) {
                if (StringUtil.isNotEmpty(str)) {
                    msg += str + ",";
                }
            }
            if(msg.endsWith(",")){
                msg.substring(0, msg.lastIndexOf(","));
            }
            return msg;
        } catch (IOException e) {
            logger.error("读取错误信息失败！", e);
            throw e;
        } finally {
            try {
                if (br != null) {
                    br.close();
                }
                if (reader != null) {
                    reader.close();
                }
                if (input != null) {
                    input.close();
                }
            } catch (IOException e) {
                logger.error("关闭文件流失败！", e);
                throw e;
            }
        }
    }

    private static Map<String, Object> execCommand(String[] cmdStr) throws IOException {
        Process p = null;
        Map<String, Object> map = new HashMap<>();
        try {
            p = Runtime.getRuntime().exec(cmdStr);
            logger.info("执行错误信息： " + printErrorStream(p.getErrorStream()));
            map = printStream(p.getInputStream());
        } catch (IOException e) {
            logger.error("启动服务失败！", e);
            throw e;
        } catch (Exception e) {
            logger.error("获取执行结果失败！", e);
            throw e;
        } finally {
            if (p != null) {
                p.destroy();
            }
        }
        return map;
    }

    /**
     * 启动服务
     * @param serviceName 右键 指定服务项-》属性 -》服务名称
     * @return
     * @throws IOException 
     */
    public static Map<String, Object> startService(String serviceName) throws IOException {
        String[] cmdStr = { "cmd", "/C", " net start " + serviceName };//runAs /user:Administrator
        logger.info(Arrays.toString(cmdStr));
        try {
            return execCommand(cmdStr);
        } catch (IOException e) {
            logger.error("开启服务失败！", e);
            throw e;
        }
    }

    /**
     * 关闭服务
     * @param serviceName 右键 指定服务项-》属性 -》服务名称
     * @return
     * @throws IOException 
     */
    public static Map<String, Object> stopService(String serviceName) throws IOException {
        String[] cmdStr = { "cmd", "/C", "net stop " + serviceName };//runAs /user:Administrator 
        logger.info(Arrays.toString(cmdStr));
        try {
            return execCommand(cmdStr);
        } catch (IOException e) {
            logger.error("关闭服务失败！", e);
            throw e;
        }
    }

    /**
     * 禁用服务
     * @param serviceName
     * @return
     * @throws IOException 
     */
    public static Map<String, Object> disableService(String serviceName) throws IOException {
        String[] cmdStr = { "cmd", "/C", "sc config " + serviceName + " start= disabled" };//runAs /user:Administrator 
        logger.info(Arrays.toString(cmdStr));
        try {
            return execCommand(cmdStr);
        } catch (IOException e) {
            logger.error("关闭服务失败！", e);
            throw e;
        }
    }

    /**
     * 启用服务 --自动
     * @param serviceName
     * @return
     * @throws IOException 
     */
    public static Map<String, Object> enableService(String serviceName) throws IOException {
        String[] cmdStr = { "cmd", "/C", "sc config " + serviceName + " start= auto" };//runAs /user:Administrator 
        logger.info(Arrays.toString(cmdStr));
        try {
            return execCommand(cmdStr);
        } catch (IOException e) {
            logger.error("关闭服务失败！", e);
            throw e;
        }
    }

    /**
     * 启用服务 --手动
     * @param serviceName
     * @return
     * @throws IOException 
     */
    public static Map<String, Object> demandService(String serviceName) throws IOException {
        String[] cmdStr = { "cmd", "/C", "sc config " + serviceName + " start= demand" };//runAs /user:Administrator 
        logger.info(Arrays.toString(cmdStr));
        try {
            return execCommand(cmdStr);
        } catch (IOException e) {
            logger.error("关闭服务失败！", e);
            throw e;
        }
    }

    /**
     * 
     * @param serviceName 映像名称  XXXX.exe
     * @return
     * @throws IOException 
     */
    public static Map<String, Object> getTaskDetail(String taskName) throws IOException {
        String[] cmdStr = { "cmd", "/C", "wmic process where name='" + taskName + "' list full" };
        logger.info(Arrays.toString(cmdStr));
        try {
            return execCommand(cmdStr);
        } catch (IOException e) {
            logger.error("关闭服务失败！", e);
            throw e;
        }
    }

    /**
     * 
     * @param processId PID
     * @return
     * @throws IOException 
     */
    public static Map<String, Object> getTaskDetail(Integer processId) throws IOException {
        String[] cmdStr = { "cmd", "/C", "wmic process where processid='" + processId + "' list full" };// get /format:value
        logger.info(Arrays.toString(cmdStr));
        try {
            return execCommand(cmdStr);
        } catch (IOException e) {
            logger.error("关闭服务失败！", e);
            throw e;
        }
    }

    public static List<Map<String, Object>> getAllTaskDetail() throws IOException {
        String[] cmdStr = { "cmd", "/C", "wmic process get /value" };
        logger.info(Arrays.toString(cmdStr));
        List<Map<String, Object>> list = null;
        try {
            list = getAllResult(cmdStr, 45);
        } catch (IOException e) {
            logger.error("获取所有进程信息失败！", e);
            throw e;
        }
        return list;
    }

    public static List<Map<String, Object>> getAllService() throws IOException {
        String[] cmdStr = { "cmd", "/C", "wmic service get /value" };
        logger.info(Arrays.toString(cmdStr));
        List<Map<String, Object>> list = null;
        try {
            list = getAllResult(cmdStr, 25);
        } catch (IOException e) {
            logger.error("获取所有服务信息失败！", e);
            throw e;
        }
        return list;
    }

    /**
     * 
     * @param serviceName 右键 指定服务项-》属性 -》服务名称
     * @return
     * @throws IOException 
     */
    public static Map<String, Object> getServiceDetail(String serviceName) throws IOException {
        String[] cmdStr = { "cmd", "/C", "wmic service where name='" + serviceName + "' list full" };
        logger.info(Arrays.toString(cmdStr));
        try {
            return execCommand(cmdStr);
        } catch (IOException e) {
            logger.error("关闭服务失败！", e);
            throw e;
        }
    }

    /**
     * 
     * @param processId PID
     * @return
     * @throws IOException 
     */
    public static Map<String, Object> getServiceDetail(Integer processId) throws IOException {
        String[] cmdStr = { "cmd", "/C", "wmic service where processid='" + processId + "' list full" };
        logger.info(Arrays.toString(cmdStr));
        try {
            return execCommand(cmdStr);
        } catch (IOException e) {
            logger.error("关闭服务失败！", e);
            throw e;
        }
    }

    public static Map<String, Object> createProcess(String taskpath) throws IOException {
        String[] cmdStr = { "cmd", "/C", "wmic process call create'" + taskpath + "'" };
        try {
            return execCommand(cmdStr);
        } catch (IOException e) {
            logger.error("关闭服务失败！", e);
            throw e;
        }
    }

    public static Map<String, Object> deleteProcess(String taskname) throws IOException {
        String[] cmdStr = { "cmd", "/C", " wmic process where name='" + taskname + "' delete" };//runAs /user:Administrator
        try {
            return execCommand(cmdStr);
        } catch (IOException e) {
            logger.error("关闭服务失败！", e);
            throw e;
        }
    }

    /**
     * 计算某进程cpu使用率
     * @param processName
     * @return
     * @throws Exception
     * @see sysTime：表示该时间段内总的CPU时间=CPU处于用户态和内核态CPU时间的总和，即sysTime =kerneTimel + userTime（注：这里并不包括idleTime，因为当CPU处于空闲状态时，实在内核模式下运行System Idle Process这个进程，所以kernelTime实际上已经包含了idleTime）；
            idleTime：表示在该时间段内CPU处于空闲状态的时间；CPU% = 1 – idleTime / sysTime * 100 
     */
    public static String getCpuRatioForWindows(String processName) throws Exception {
        String[] cmdStr = { "cmd", "/C",
                "wmic process get Caption,CommandLine,KernelModeTime,ReadOperationCount,ThreadCount,UserModeTime,WriteOperationCount /value" };
        try {
            List<Map<String, Object>> list1 = getAllResult(cmdStr, 7);
            long[] data1 = getCpuTime(list1, processName);
            Thread.sleep(1000);
            List<Map<String, Object>> list2 = getAllResult(cmdStr, 7);// get(p.getInputStream());
            long[] data2 = getCpuTime(list2, processName);
            long proctime = data2[2] - data1[2];
            long totaltime = data2[1] - data1[1]; // + data2[0] - data1[0]
            if(totaltime==0){
                return "0%";
            }
            return Double.valueOf(10000 * proctime * 1.0 / totaltime).intValue()/100.00 + "%";
        } catch (Exception e) {
            logger.error("获取CPU占用率失败！", e);
            throw e;
        }
    }

    private static long[] getCpuTime(List<Map<String, Object>> list, String processName) {
        long[] data = new long[3];
        long idletime = 0;
        long kneltime = 0;
        long usertime = 0;
        long processTime = 0;
        String caption = "";
        String kmtm = "";
        String umtm = "";
        for (Map<String, Object> m : list) {
            caption = m.get("Caption").toString();
            kmtm = m.get("KernelModeTime").toString();
            umtm = m.get("UserModeTime").toString();
            if (caption.equals("System Idle Process") || caption.equals("System")) {
                if (kmtm != null && !kmtm.equals("")) {
                    idletime += Long.parseLong(kmtm);
                }
                if (umtm != null && !umtm.equals("")) {
                    idletime += Long.parseLong(umtm);
                }
            }
            if (caption.equals(processName)) {
                if (kmtm != null && !kmtm.equals("")) {
                    processTime += Long.parseLong(kmtm);
                }
                if (umtm != null && !umtm.equals("")) {
                    processTime += Long.parseLong(umtm);
                }
            }
            if (kmtm != null && !kmtm.equals("")) {
                kneltime += Long.parseLong(kmtm);
            }
            if (umtm != null && !umtm.equals("")) {
                usertime += Long.parseLong(umtm);
            }
        }
        data[0] = idletime;
        data[1] = kneltime + usertime;
        data[2] = processTime;
        return data;
    }

       就这么点，这么简单，完全不需要解释。

　　当时查资料的时候，借阅了网上众多大神的博客，论坛什么的，如果其中有内容侵犯了你的权益，请及时与我联系。

转载于:https://www.cnblogs.com/mituonline/p/4449535.html

weixin_30879833
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java获取 windows服务状态_从Java应用程序中查找Windows服务的状态？
weixin_32954401的博客
02-16 871
在下面的示例中,您可以找到如何检查windws服务状态,并且可以解析以执行某些操作import java.util.*;import java.sql.*;import java.io.*;import java.text.*;public class doscmd{public static void main(String args[]){try{Process p=Runtime.getRu...
java检测服务_java检测Windows服务（NT服务）是否安装、启动
weixin_35986497的博客
03-02 348
之前项目写的Windows服务需要集成到B/S架构系统中去，方便用户的操作。用到的函数是Runtime.getRuntime().exec()。实现如下：Process process = Runtime.getRuntime().exec("sc query AzureStorageService");//查询服务是否安装InputStream inputStream = process.get...
java获取 windows服务状态,在java中，有没有办法检查Windows服务的状态？
weixin_42307478的博客
02-16 222
I am looking for a library that will allow me to look up the status of a windows service to verify that the service is started and running. I looked into the Sigar library, but it is GPL and therefor...
查看Windows中服务的状态[Daily works with Ruby]
weixin_30548917的博客
07-16 791
起因： 我时常需要查看一些Windows Service的状态，每次使用控制面板->服务这种方式来查看服务状态不仅浪费时间而且也很无聊，干脆写个Ruby脚本吧。让Ruby脚本来通知我某个Windows Service的状态是如何，并根据状态给我一些提示。 主要内容： 你可以从本篇daily works with ruby中看到以下技术/工具的使用。 使用RubyG...
JAVA代码控制windows服务
weixin_38166689的博客
08-31 392
JAVA代码控制windows服务。 注意，如果需要连续执行两条命令比如先cd到某个盘里，再执行某个操作，要用&连接两个语句。 import java.io.IOException; import java.io.InputStream; import java.net.Socket; import java.util.Scanner; public class WindowSe...
Java多线程进程应对同一程序运行资源
08-10
我们可以模拟铁路售票系统，使用四个售票点来售卖某日某次列车的100张车票，每个售票点用一个线程表示。通过这种方式，可以更好地理解Java多线程进程的实现方式。 Java多线程进程的优点 Java多线程进程有以下几个...
java实现操作系统的短进程作业调度示例分享
09-04
在操作系统中，进程调度是一项重要的功能，用于决定哪些进程应该获得CPU的执行权。本示例中，我们关注的是短进程优先（Shortest Job First，SJF）调度算法的Java实现。 短进程优先调度算法是一种非抢占式调度策略，...
java管理windows系统内存_java释放内存缓存_java获得CPU使用率_系统内存_硬盘_进程源代码
12-19
"java管理windows系统内存_java释放内存缓存_java获得CPU使用率_系统内存_硬盘_进程源代码" 在Windows操作系统中，内存管理是一个非常重要的方面。Windows实现按需调页的虚拟内存机制，使得应用程序可以使用超过...
记一次tomcat进程cpu占用过高的问题排查记录
09-29
接下来，作者使用了一个脚本来分析每个线程的CPU使用量，通过`ps`和`awk`命令获取并计算线程的CPU占用。结果显示，没有长期占用CPU的线程，因此怀疑可能是由于JVM内存不足导致的频繁垃圾回收。然而，`jstat -gc`显示...
java版斗地主源码-px:精心设计的多进程游戏服务器
06-04
node作为脚本语言性质，决定了它不适合做高cpu的业务，不同于java之类采用的是单线程，多进程的模式来处理海量请求。每个进程其实和传统web服务器一样都是镜像一般处理相同业务（登录，聊天，战斗，交易等等），这样...
java获取服务器基本信息的方法
09-03
主要介绍了java获取服务器基本信息的方法,涉及java获取系统CPU、内存及操作系统等相关信息的技巧,具有一定参考借鉴价值,需要的朋友可以参考下
windows系统下查看运行的服务
weixin_33743880的博客
08-16 852
一、开始->控制面板->管理工具->服务二、运行->输入services.msc例如Task Scheduler服务 使用户能在此计算机上配置和制定自动任务的日程。如果此服务被终止，这些任务将无法再日程时间里运行。如果此服务被禁用，任何依赖它的服务都将无法启动。默认，task scheduler服务是自动启动，随着系统启动而启动。依存关系中，依赖...
windows java cpu 100_在windows下揪出java程序占用cpu很高的线程并完美解决
weixin_31957989的博客
02-16 718
我的一个java程序偶尔会出现cpu占用很高的情况一直不知道什么原因今天终于抽时间解决了系统是win2003jvisualvm 和 jconsole貌似都只能看到总共占用的cpu 看不到每个线程分别占用的cpu呢所以在windows平台上要找出到底是哪个线程占用的cpu还不那么容易，linux用top就简单多了最后的解决方法:1.找到java进程对应的pid。找pid的方法是:打开任务管理器，然后...
windows下揪出java程序占用cpu很高的线程 并找到问题代码 死循环线程代码
热门推荐
hexin373的专栏
04-24 4万+
我的一个java程序偶尔会出现cpu占用很高的情况 一直不知道什么原因 今天终于抽时间解决了 系统是win2003 jvisualvm 和 jconsole貌似都只能看到总共占用的cpu 看不到每个线程分别占用的cpu呢 所以在windows平台上要找出到底是哪个线程占用的cpu还不那么容易，linux用top就简单多了 最后的解决方法: 1.找到
java如何监控系统进程和服务的状态
老紫竹的专栏
12-30 1万+
源于网友的一个问题：http://topic.csdn.net/u/20081210/14/e3b92695-d8cf-4c79-8d60-279fbd8ec925.htmla．通过监测关键进程 当选择此项时，系统提供以下属性项： 服务器IP（选择项），进程名称（选择项，根据服务器IP自动过滤），进程友好名称，进程路径，进程端口，是否关键进程，运行参数，失败是否自动重启，进程描述。 b．
java 查看远程服务器 cpu 使用率_Java性能调优的7个实用技巧分享
weixin_28358083的博客
12-25 1156
随着应用的数据量不断的增加，系统的反应一般会越来越慢，这个时候我们就需要性能调优。性能调优的步骤如下：Java 应用性能优化是一个老生常谈的话题，典型的性能问题如页面响应慢、接口超时，服务器负载高、并发数低，数据库频繁死锁等。尤其是在“糙快猛”的互联网开发模式大行其道的今天，随着系统访问量的日益增加和代码的臃肿，各种性能问题开始纷至沓来。Java 应用性能的瓶颈点非常多，比如磁盘、内存、网络 I/...
如何排除Java进程CPU占用高的问题
最新发布
02-17
如果Java进程的CPU占用率较高，可能有多种原因，以下是一些常见的排除步骤： 1. 确认Java版本：首先，您应该确认Java版本是否与应用程序或框架的要求相符。Java版本过低或过高可能导致CPU占用率过高。 2. 确认应用程序是否有异常行为：检查应用程序的日志文件和监视控制台输出，以查找异常行为，如无限循环、内存泄漏、线程阻塞等。这些异常行为可能导致CPU占用率过高。 3. 分析堆栈信息：通过分析Java堆栈信息，可以确定哪些线程正在运行以及正在执行哪些代码。您可以使用Java虚拟机自带的工具，如jstack和jmap，来获取和分析堆栈信息。 4. 监视系统资源：您可以使用操作系统自带的工具，如top（Linux）和Task Manager（Windows），来监视系统资源的使用情况。如果CPU使用率过高，您可以检查哪些进程正在使用大量CPU资源。 5. 调整Java虚拟机参数：通过调整Java虚拟机参数，可以优化应用程序的性能。例如，您可以调整垃圾收集器的参数，以减少垃圾回收时间和频率。您可以使用Java虚拟机自带的工具，如jstat和jconsole，来监视和调整Java虚拟机参数。 6. 升级硬件：如果CPU占用率过高且无法通过优化Java虚拟机参数来解决，您可以考虑升级硬件，如添加更多的CPU或内存。 以上是一些常见的排除步骤，您可以根据具体情况选择相应的方法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值