精华内容
下载资源
问答
  • java监控linux cpu使用率

    2010-07-15 10:29:17
    java实现linux下的cpu资源使用率监控
  • Java监控Linux服务器 Top 状态

    千次阅读 2021-06-04 17:09:39
    <dependency> <groupId>com.jcraft</groupId> <artifactId>jsch</artifactId> <version>0.1.55<...import java.io.BufferedReader; import java.io.IOException;

    

    <dependency>
      <groupId>com.jcraft</groupId>
      <artifactId>jsch</artifactId>
      <version>0.1.55</version>
    </dependency>
    
    import com.jcraft.jsch.*;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.util.HashMap;
    import java.util.Map;
     
    /**
     * 远程调用Linux shell 命令
     *
     * @author wei.Li by 14-9-2.
     */
    class LinuxStateForShell {
     
     
        public static final String CPU_MEM_SHELL = "top -b -n 1";
        public static final String FILES_SHELL = "df -hl";
        public static final String[] COMMANDS = {CPU_MEM_SHELL, FILES_SHELL};
        public static final String LINE_SEPARATOR = System.getProperty("line.separator");
        private static Session session;
     
        /**
         * 连接到指定的HOST
         *
         * @return isConnect
         * @throws JSchException JSchException
         */
        private static boolean connect(String user, String passwd, String host) {
            JSch jsch = new JSch();
            try {
                session = jsch.getSession(user, host, 22);
                session.setPassword(passwd);
     
                java.util.Properties config = new java.util.Properties();
                config.put("StrictHostKeyChecking", "no");
                session.setConfig(config);
     
                session.connect();
            } catch (JSchException e) {
                e.printStackTrace();
                System.out.println("connect error !");
                return false;
            }
            return true;
        }
     
        /**
         * 远程连接Linux 服务器 执行相关的命令
         *
         * @param commands 执行的脚本
         * @param user     远程连接的用户名
         * @param passwd   远程连接的密码
         * @param host     远程连接的主机IP
         * @return 最终命令返回信息
         */
        public static Map<String, String> runDistanceShell(String[] commands, String user, String passwd, String host) {
            if (!connect(user, passwd, host)) {
                return null;
            }
            Map<String, String> map = new HashMap<>();
            StringBuilder stringBuffer;
     
            BufferedReader reader = null;
            Channel channel = null;
            try {
                for (String command : commands) {
                    stringBuffer = new StringBuilder();
                    channel = session.openChannel("exec");
                    ((ChannelExec) channel).setCommand(command);
     
                    channel.setInputStream(null);
                    ((ChannelExec) channel).setErrStream(System.err);
     
                    channel.connect();
                    InputStream in = channel.getInputStream();
                    reader = new BufferedReader(new InputStreamReader(in));
                    String buf;
                    while ((buf = reader.readLine()) != null) {
     
                        //舍弃PID 进程信息
                        if (buf.contains("PID")) {
                            break;
                        }
                        stringBuffer.append(buf.trim()).append(LINE_SEPARATOR);
                    }
                    //每个命令存储自己返回数据-用于后续对返回数据进行处理
                    map.put(command, stringBuffer.toString());
                }
            } catch (IOException | JSchException e) {
                e.printStackTrace();
            } finally {
                try {
                    if (reader != null) {
                        reader.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (channel != null) {
                    channel.disconnect();
                }
                session.disconnect();
            }
            return map;
        }
     
     
        /**
         * 直接在本地执行 shell
         *
         * @param commands 执行的脚本
         * @return 执行结果信息
         */
        public static Map<String, String> runLocalShell(String[] commands) {
            Runtime runtime = Runtime.getRuntime();
     
            Map<String, String> map = new HashMap<>();
            StringBuilder stringBuffer;
     
            BufferedReader reader;
            Process process;
            for (String command : commands) {
                stringBuffer = new StringBuilder();
                try {
                    process = runtime.exec(command);
                    InputStream inputStream = process.getInputStream();
                    reader = new BufferedReader(new InputStreamReader(inputStream));
                    String buf;
                    while ((buf = reader.readLine()) != null) {
                        //舍弃PID 进程信息
                        if (buf.contains("PID")) {
                            break;
                        }
                        stringBuffer.append(buf.trim()).append(LINE_SEPARATOR);
                    }
     
                } catch (IOException e) {
                    e.printStackTrace();
                    return null;
                }
                //每个命令存储自己返回数据-用于后续对返回数据进行处理
                map.put(command, stringBuffer.toString());
            }
            return map;
        }
     
     
        /**
         * 处理 shell 返回的信息
         * <p>
         * 具体处理过程以服务器返回数据格式为准
         * 不同的Linux 版本返回信息格式不同
         *
         * @param result shell 返回的信息
         * @return 最终处理后的信息
         */
        private static String disposeResultMessage(Map<String, String> result) {
     
            StringBuilder buffer = new StringBuilder();
     
            for (String command : COMMANDS) {
                String commandResult = result.get(command);
                if (null == commandResult) continue;
     
                if (command.equals(CPU_MEM_SHELL)) {
                    String[] strings = commandResult.split(LINE_SEPARATOR);
                    //将返回结果按换行符分割
                    for (String line : strings) {
                        line = line.toUpperCase();//转大写处理
     
                        //处理CPU Cpu(s): 10.8%us,  0.9%sy,  0.0%ni, 87.6%id,  0.7%wa,  0.0%hi,  0.0%si,  0.0%st
                        if (line.startsWith("CPU(S):")) {
                            String cpuStr = "CPU 用户使用占有率:";
                            try {
                                cpuStr += line.split(":")[1].split(",")[0].replace("US", "");
                            } catch (Exception e) {
                                e.printStackTrace();
                                cpuStr += "计算过程出错";
                            }
                            buffer.append(cpuStr).append(LINE_SEPARATOR);
     
                            //处理内存 Mem:  66100704k total, 65323404k used,   777300k free,    89940k buffers
                        } else if (line.startsWith("MEM")) {
                            String memStr = "内存使用情况:";
                            try {
                                memStr += line.split(":")[1]
                                        .replace("TOTAL", "总计")
                                        .replace("USED", "已使用")
                                        .replace("FREE", "空闲")
                                        .replace("BUFFERS", "缓存");
     
                            } catch (Exception e) {
                                e.printStackTrace();
                                memStr += "计算过程出错";
                                buffer.append(memStr).append(LINE_SEPARATOR);
                                continue;
                            }
                            buffer.append(memStr).append(LINE_SEPARATOR);
     
                        }
                    }
                } else if (command.equals(FILES_SHELL)) {
                    //处理系统磁盘状态
                    buffer.append("系统磁盘状态:");
                    try {
                        buffer.append(disposeFilesSystem(commandResult)).append(LINE_SEPARATOR);
                    } catch (Exception e) {
                        e.printStackTrace();
                        buffer.append("计算过程出错").append(LINE_SEPARATOR);
                    }
                }
            }
     
            return buffer.toString();
        }
     
        //处理系统磁盘状态
     
        /**
         * Filesystem            Size  Used Avail Use% Mounted on
         * /dev/sda3             442G  327G   93G  78% /
         * tmpfs                  32G     0   32G   0% /dev/shm
         * /dev/sda1             788M   60M  689M   8% /boot
         * /dev/md0              1.9T  483G  1.4T  26% /ezsonar
         *
         * @param commandResult 处理系统磁盘状态shell执行结果
         * @return 处理后的结果
         */
        private static String disposeFilesSystem(String commandResult) {
            String[] strings = commandResult.split(LINE_SEPARATOR);
     
            // final String PATTERN_TEMPLATE = "([a-zA-Z0-9%_/]*)\\s";
            int size = 0;
            int used = 0;
            for (int i = 0; i < strings.length - 1; i++) {
                if (i == 0) continue;
     
                int temp = 0;
                for (String s : strings[i].split("\\b")) {
                    if (temp == 0) {
                        temp++;
                        continue;
                    }
                    if (!s.trim().isEmpty()) {
                        if (temp == 1) {
                            size += disposeUnit(s);
                            temp++;
                        } else {
                            used += disposeUnit(s);
                            temp = 0;
                        }
                    }
                }
            }
            return new StringBuilder().append("大小 ").append(size).append("G , 已使用").append(used).append("G ,空闲")
                    .append(size - used).append("G").toString();
        }
     
        /**
         * 处理单位转换
         * K/KB/M/T 最终转换为G 处理
         *
         * @param s 带单位的数据字符串
         * @return 以G 为单位处理后的数值
         */
        private static int disposeUnit(String s) {
     
            try {
                s = s.toUpperCase();
                String lastIndex = s.substring(s.length() - 1);
                String num = s.substring(0, s.length() - 1);
                int parseInt = Integer.parseInt(num);
                if (lastIndex.equals("G")) {
                    return parseInt;
                } else if (lastIndex.equals("T")) {
                    return parseInt * 1024;
                } else if (lastIndex.equals("M")) {
                    return parseInt / 1024;
                } else if (lastIndex.equals("K") || lastIndex.equals("KB")) {
                    return parseInt / (1024 * 1024);
                }
            } catch (NumberFormatException e) {
                e.printStackTrace();
                return 0;
            }
            return 0;
        }
     
        public static void main(String[] args) {
    //        Map<String, String> result = runDistanceShell(COMMANDS, "root", "admin123", "192.168.1.1");
    
            System.out.println(disposeResultMessage(runLocalShell(COMMANDS)));
        }
     
    }
    
    展开全文
  • 最近有个需求,监控服务器磁盘使用情况。...其实原理很简单,就是使用java执行Linux执行,然后解析显示结果。 依赖 1 <dependency> 2 <groupId>org.apache.commons</groupId> 3 &l...

    最近有个需求,监控服务器磁盘使用情况。起因是因为站点日志写满了硬盘,导致服务宕机。需要在某个临界点发送通知给管理员,及时处理异常。

    其实原理很简单,就是使用java执行Linux执行,然后解析显示结果。

    依赖

     1 <dependency>
     2     <groupId>org.apache.commons</groupId>
     3     <artifactId>commons-io</artifactId>
     4     <version>1.3.2</version>
     5 </dependency>
     6 <dependency>
     7     <groupId>com.alibaba</groupId>
     8     <artifactId>fastjson</artifactId>
     9     <version>1.2.56</version>
    10 </dependency>

    简单实现

    package com.test.practice;
    
    import java.io.BufferedReader;
    import java.io.InputStreamReader;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    import org.apache.commons.io.IOUtils;
    
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONArray;
    import com.alibaba.fastjson.JSONObject;
    
    public class DeskMonitor {
    
        public static void main(String[] args) {
            try {
                String deskMonitorConfig = "{deskList:[{name:\"/dev/vda1\", useRate:40}]}";
                JSONObject deskMonitorObj = JSON.parseObject(deskMonitorConfig);
                JSONArray deskArray = deskMonitorObj.getJSONArray("deskList");
                Runtime rt = Runtime.getRuntime();
                Process p = rt.exec("df -hl");// df -hl 查看硬盘空间
                List<String> result = IOUtils.readLines(p.getInputStream(), "GBK");
                for (String line: result) {
                    for (int i = 0; i < deskArray.size(); i++) {
                        JSONObject deskObj = deskArray.getObject(i, JSONObject.class);
                        String deskName = deskObj.getString("name");
                        double deskUseRate = deskObj.getDoubleValue("useRate");
                        if (line.contains(deskName)) {
                            System.out.println(line);
                            String[] items = line.split("%")[0].split(" ");
                            int lastIndex = items.length - 1;
                            double useRateLocal = Double.parseDouble(items[lastIndex].trim());
                            if (useRateLocal >= deskUseRate) {
                                // 报警
                                System.out.println("===>>>"+"磁盘名称:"+deskName+"磁盘使用率:"+useRateLocal);
                            }
                        }
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        
    }

    以上基本能满足自动监控需求。可将上面代码放入定时任务每分钟检查。报警部分改为发邮件或其他方式提醒。

     

    服务器结果

    发送的是语音短信,怕其他方式不够及时。

    转载于:https://www.cnblogs.com/woodafeng/p/10370333.html

    展开全文
  • java监控linux硬件,定时发送邮件

    千次阅读 2018-08-01 16:06:45
    目录 1.整体架构图 ... 主要功能 :监控linux的cpu和内存使用率,当频率过高时,发送邮件提醒功能。 这里的SendMail工具类在上一章节写过,需要的朋友可以去看下,付链接 https://blog.csdn.net/qq_42...

    目录

    1.整体架构图

    2.代码

    3.邮件发送过慢的问题


    需求:用java代码监控Linux服务器的cpu和内存使用,一旦超过指定值,就发送邮件提醒。

    1.整体架构图

        主要功能 :监控linux的cpu和内存使用率,当频率过高时,发送邮件提醒功能。

        这里的SendMail工具类在上一章节写过,需要的朋友可以去看下,付链接

    https://blog.csdn.net/qq_42035966/article/details/81332504

         还有一个发送邮件问题,在linux上发送邮件出现延迟问题,需要去配置一下,第三点会讲下

    2.代码

        cpuinfo()  读取linux下的/proc/stat文件,获取cpu信息。

        cpuUsage()  获取两次cpuinfo的内容,比较两次的差别,得到cpu使用率。

       memoryUsage()  读取linux下的/proc/meminfo文件,获取内存信息。

       main() 主入口,当使用率过高,定时发送邮件提醒。

    package LinuxMonitorUtils;
    
    import java.io.BufferedReader;
    import java.io.FileInputStream;
    import java.io.InputStreamReader;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.StringTokenizer;
    import java.util.Timer;
    import java.util.TimerTask;
    
    import sendMailUtils.SendMail;
    
    public class OSUtils {
    
    	/**
    	 * 功能:获取Linux系统cpu使用率
    	 */
    	public static float cpuUsage() {
    		try {
    			Map<?, ?> map1 = OSUtils.cpuinfo();
    			Thread.sleep(5 * 1000);
    			Map<?, ?> map2 = OSUtils.cpuinfo();
    
    			long user1 = Long.parseLong(map1.get("user").toString());
    			long nice1 = Long.parseLong(map1.get("nice").toString());
    			long system1 = Long.parseLong(map1.get("system").toString());
    			long idle1 = Long.parseLong(map1.get("idle").toString());
    
    			long user2 = Long.parseLong(map2.get("user").toString());
    			long nice2 = Long.parseLong(map2.get("nice").toString());
    			long system2 = Long.parseLong(map2.get("system").toString());
    			long idle2 = Long.parseLong(map2.get("idle").toString());
    
    			long total1 = user1 + system1 + nice1;
    			long total2 = user2 + system2 + nice2;
    			float total = total2 - total1;
    
    			long totalIdle1 = user1 + nice1 + system1 + idle1;
    			long totalIdle2 = user2 + nice2 + system2 + idle2;
    			float totalidle = totalIdle2 - totalIdle1;
    
    			float cpusage = (total / totalidle) * 100;
    			System.out.println("cpu使用率:"+ cpusage+"%");
    			return cpusage;
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		return 0;
    	}
    
    	/**
    	 * 功能:CPU使用信息
    	 */
    	public static Map<?, ?> cpuinfo() {
    		InputStreamReader inputs = null;
    		BufferedReader buffer = null;
    		Map<String, Object> map = new HashMap<String, Object>();
    		try {
    			inputs = new InputStreamReader(new FileInputStream("/proc/stat"));
    			buffer = new BufferedReader(inputs);
    			String line = "";
    			while (true) {
    				line = buffer.readLine();
    				if (line == null) {
    					break;
    				}
    				if (line.startsWith("cpu")) {
    					StringTokenizer tokenizer = new StringTokenizer(line);
    					List<String> temp = new ArrayList<String>();
    					while (tokenizer.hasMoreElements()) {
    						String value = tokenizer.nextToken();
    						temp.add(value);
    					}
    					map.put("user", temp.get(1));
    					map.put("nice", temp.get(2));
    					map.put("system", temp.get(3));
    					map.put("idle", temp.get(4));
    					map.put("iowait", temp.get(5));
    					map.put("irq", temp.get(6));
    					map.put("softirq", temp.get(7));
    					map.put("stealstolen", temp.get(8));
    					break;
    				}
    			}
    		} catch (Exception e) {
    			e.printStackTrace();
    		} finally {
    			try {
    				buffer.close();
    				inputs.close();
    			} catch (Exception e2) {
    				e2.printStackTrace();
    			}
    		}
    		return map;
    	}
    
    	/**
    	 * 功能:内存使用率
    	 */
    	public static long memoryUsage() {
    		Map<String, Object> map = new HashMap<String, Object>();
    		InputStreamReader inputs = null;
    		BufferedReader buffer = null;
    		try {
    			inputs = new InputStreamReader(new FileInputStream("/proc/meminfo"));
    			buffer = new BufferedReader(inputs);
    			String line = "";
    			while (true) {
    				line = buffer.readLine();
    				if (line == null)
    					break;
    				int beginIndex = 0;
    				int endIndex = line.indexOf(":");
    				if (endIndex != -1) {
    					String key = line.substring(beginIndex, endIndex);
    					beginIndex = endIndex + 1;
    					endIndex = line.length();
    					String memory = line.substring(beginIndex, endIndex);
    					String value = memory.replace("kB", "").trim();
    					map.put(key, value);
    				}
    			}
    
    			long memTotal = Long.parseLong(map.get("MemTotal").toString());
    			System.out.println("内存总量"+memTotal+"KB");
    			long memFree = Long.parseLong(map.get("MemFree").toString());
    			System.out.println("剩余内存"+memFree+"KB");
    			long memused = memTotal - memFree;
    			System.out.println("已用内存"+memused+"KB");
    			long buffers = Long.parseLong(map.get("Buffers").toString());
    			long cached = Long.parseLong(map.get("Cached").toString());
    
    			double usage = (double) (memused - buffers - cached) / memTotal * 100;
    			System.out.println("内存使用率"+usage+"%");
    			
    			return memFree;
    		} catch (Exception e) {
    			e.printStackTrace();
    		} finally {
    			try {
    				buffer.close();
    				inputs.close();
    			} catch (Exception e2) {
    				e2.printStackTrace();
    			}
    		}
    		return 0;
    	}
    	
    	
    	/**
    	 * 主入口
    	 * @param args
    	 */
    	public static void main(String[] args) {
    //		//1. 创建计时器类
    //		Timer timer = new Timer();
    //		//2. 创建任务类
    //		TimerTask task = new TimerTask() {
    //			@Override
    //			public void run() {
    					//cup使用率
    					float cpuUsage = cpuUsage();
    					if(cpuUsage > 10.0 ){
    						SendMail.sendMail("xxxxx@qq.com", "服务器cpu使用率过高,请注意查看", "服务器提醒");
    					}
    					//内存使用情况
    					long memoryUsage = memoryUsage();
    					if((memoryUsage/1024) < 100){
    						SendMail.sendMail("xxxxx@qq.com","服务器内存剩余空间不足,请注意查看", "服务器提醒");
    					}
    					System.out.println("-----------");
    //			}
    //		};
    //		timer.schedule(task, 1000, 1000*10);
    		
    	}
    }
    

    3.邮件发送过慢的问题

       在测试代码的时候,我们发现了邮件发送过慢的问题,这在本机上并不在,所以我们还需要修改下linux的配置文件

        在linux控制台输入,  查看本地端口的配置,因为sendmail监听的是127.0.0.1,但却无法确认主机名peixin,所以在我们的127.0.0.1 最后面配置主机名,例如我的是peixin,在最后配置peixin,之后重启下邮件发送。

        # cat /etc/hosts

    127.0.0.1  localhost localhost.localdomain localhost4 localhost4.localdomain4 peixin

    ::1             localhost localhost.localdomain localhost6 localhost6.localdomain6

        # service sendmail restart

    展开全文
  • java监控linux服务器CPU,内存等信息

    千次阅读 2017-07-18 14:51:56
    一开始我打算通过linux shell获取然后输出到文件,java读取文件获得。后来回想一切皆文件的linux应该本来就有记录在文件中,经过查找资料,找到了解决方法。 资料参考:http://www.jb51.net/article/75002.htm* ...

    最近公司在做爬虫系统,我接到一个需求是获取服务器CPU,内存等信息。一开始我打算通过linux shell获取然后输出到文件,java读取文件获得。后来回想一切皆文件的linux应该本来就有记录在文件中,经过查找资料,找到了解决方法。
    资料参考:http://www.jb51.net/article/75002.htm

    * 取得linux系统下的cpu、内存信息  
    *  
    * */  
    public  final  class LinuxSystemTool  
    {  
    /**  
    * get memory by used info  
    *  
    * @return int[] result  
    * result.length==4;int[0]=MemTotal;int[1]=MemFree;int[2]=SwapTotal;int[3]=SwapFree;  
    * @throws IOException  
    * @throws InterruptedException  
    */ 
    public  static  int [] getMemInfo() throws IOException, InterruptedException  
    {  
    File file = new File( "/proc/meminfo" );  
    BufferedReader br = new BufferedReader( new InputStreamReader(  
    new FileInputStream(file)));  
    int [] result = new  int [ 4 ];  
    String str = null ;  
    StringTokenizer token = null ;  
    while ((str = br.readLine()) != null )  
    {  
    token = new StringTokenizer(str);  
    if (!token.hasMoreTokens())  
    continue ;  
    
    str = token.nextToken();  
    if (!token.hasMoreTokens())  
    continue ;  
    
    if (str.equalsIgnoreCase( "MemTotal:" ))  
    result[0 ] = Integer.parseInt(token.nextToken());  
    else  if (str.equalsIgnoreCase( "MemFree:" ))  
    result[1 ] = Integer.parseInt(token.nextToken());  
    else  if (str.equalsIgnoreCase( "SwapTotal:" ))  
    result[2 ] = Integer.parseInt(token.nextToken());  
    else  if (str.equalsIgnoreCase( "SwapFree:" ))  
    result[3 ] = Integer.parseInt(token.nextToken());  
    }  
    
    return result;  
    }  
    
    /**  
    * get memory by used info  
    *  
    * @return float efficiency  
    * @throws IOException  
    * @throws InterruptedException  
    */ 
    public  static  float getCpuInfo() throws IOException, InterruptedException  
    {  
    File file = new File( "/proc/stat" );  
    BufferedReader br = new BufferedReader( new InputStreamReader(  
    new FileInputStream(file)));  
    StringTokenizer token = new StringTokenizer(br.readLine());  
    token.nextToken();  
    int user1 = Integer.parseInt(token.nextToken());  
    int nice1 = Integer.parseInt(token.nextToken());  
    int sys1 = Integer.parseInt(token.nextToken());  
    int idle1 = Integer.parseInt(token.nextToken());  
    
    Thread.sleep(1000 );  
    
    br = new BufferedReader(  
    new InputStreamReader( new FileInputStream(file)));  
    token = new StringTokenizer(br.readLine());  
    token.nextToken();  
    int user2 = Integer.parseInt(token.nextToken());  
    int nice2 = Integer.parseInt(token.nextToken());  
    int sys2 = Integer.parseInt(token.nextToken());  
    int idle2 = Integer.parseInt(token.nextToken());  
    
    return ( float )((user2 + sys2 + nice2) - (user1 + sys1 + nice1)) / ( float )((user2 + nice2 + sys2 + idle2) - (user1 + nice1 + sys1 + idle1));  
    }  
    }  

    同理:要获取LINUX的CPU温度(如果文件存在):

    InputStreamReader(new FileInputStream(new File("/proc/acpi/thermal_zone/THM/temperature"))
    展开全文
  • java实现Linux服务器内存监控预警

    千次阅读 2017-12-29 11:15:20
    java程序 监控Linux内存监控 邮件预警
  • java VisualVM 远程监控linux jvm运行状态 java VisualVM 远程监控linux jvm运行状态 服务器配置 启动脚本 本地客户端连接 1.服务器配置a.进入JAVA_HOME\jre\lib\management\目录 (如何不知道java_home位置,通过...
  • java远程监控linux资源情况

    千次阅读 2014-05-22 22:25:25
    对于远程监控Linux主机系统CPU,内存使用情况,以前也使用了top等命令,但是最后还是觉得使用vmstat比较好. 运行top命令获得系统CPU使用情况有两个缺点, 第一运行top命令,执行的shell语句相对复杂. 用top...
  • java中远程监控Linux主机CPU及内存代码实现
  • javaLINUX 进行带宽使用率监控

    千次阅读 2018-05-23 16:29:39
    因为项目需要使用java对视频服务器进行带宽使用率监控,故找相关代码来研究以及使用,系统为centos7.2 首先使用 ifconfig 命令看看自己有几块网卡 ifconfig 然后使用 sudo ethtool eth0 找到自己的带宽是...
  • Linuxjava 监控 程序运行

    千次阅读 2015-11-16 14:33:03
    需求是:tomcat的java进程经常100%占用CPU,此时servlet也停止响应了,业务逻辑除了问题。 希望有一个在PC上跑的监控程序,能够在tomcat 100%占用cpu的时候杀死。同时tomcat自动重启。 过程:tomcat自动重启是通过...
  • linux java内存监控

    千次阅读 2019-09-09 11:42:11
    jmap查看Java进程对象使用情况: 使用jmap可以查看某个Java进程中每个对象有多少个实例,占用多少内存, jmap -histo 进程id 第一列,序号,无实际意义 第二列,对象实例数量 第三列,对象实例占用总内存数,单位...
  • jconsole远程监控Linux上运行的Java进程的方法: 1,在Java进程启动的时候讲监听命名放进启动命令行中 nohup java #后台启动 -Djava.rmi.server.hostname=192.168.202.27 #java进程所在的Linux ip,该行命名可以不...
  • linux java 服务 添加监控 linuxjava服务,需要监控堆栈,内存,线程等信息,借助Windows 的jdk 监控工具监控。 1、在启脚本加上 (本机ip 和端口) -Djava.rmi.server.hostname=192.168.1.1 -Dcom.sun....
  • linux jstat 监控 java GC

    千次阅读 2016-08-31 19:48:05
    性能测试过程中,我们该如何监控java虚拟机内存的使用情况,用以判断JVM是否存在内存问题呢?如何判断JVM垃圾回收是否正常?一般的top指令基本上满足不了这样的需求,因为它主要监控的是总体的系统资源,很难定位到...
  • 配置 jmc 远程监控linux上的java程序

    千次阅读 2018-01-21 12:48:38
    环境:java1.8,tomcat8,centos6.x 看了网上很多文章说很简单就能配置jmc的远程监控 但是我这里要监控的是正式服务器,一个是安全性不够,一个是按照网上的说法完全不靠谱 于是查询谷歌并自己尝试完成了配置,...
  • 现在的问题是,linux上跑着一个java程序,然后安装了JProfiler 以后却监控不到linux本机的java程序,有大神知道还应该怎么配置吗?
  • Linux的服务器启动项中添加如下信息: -Djava.rmi.server.hostname=192.168.1.101 -Dcom.sun.management.jmxremote  -Dcom.sun.management.jmxremote.port=911 -Dcom.sun.management.jmxremote.ssl=false -Dcom....
  • JAVA_OPTS="$JAVA_OPTS -Djava.rmi.server.hostname=10.100.6.9 -Dcom.sun.management.jmxremote.port=8080 -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=fal...
  • Linux系统下Java程序的基本监控

    千次阅读 2015-08-20 10:53:22
    Linux系统下Java程序的监控 当一个程序部署到linux系统中后,除了我们常用的单元测试,系统测试来确保系统正确运行之外,我们还需要一些有效的方式能够实时监控系统运行的状态,及时的发现可能出现的问题,下文中...
  • Linux - (tomcat) java进程监控及守护

    千次阅读 2017-11-15 13:08:40
    Linux服务器下需要监控某些进程的状态. 当进程不存在时, 自动启动, 当进程异常时, 自动重启. 以tomcat为例 1. 编写监控脚本(/data/bin/monitor.sh) #!/bin/sh #加载环境变量 #ALL source /etc/profile #MINE ...
  • 正在研究java实现远程监控linux服务器内存,cup,硬盘等信息,或者在远程服务器中部署采集程序,采集内存,CPU,硬盘信。搜集了一些思路正在整理测试中,有经验的朋友可以留言分享经验。 第一种方法 采用java实现...
  • <br />1、首先需要停止正在运行的服务:resin-XXX stop   2、然后在Linux的服务器启动项中添加如下信息: -Djava.rmi.server.hostname=192.168.1.122 -Dcom.sun.management.jmxremote ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 104,152
精华内容 41,660
关键字:

java监控linux

java 订阅
linux 订阅