JMX和Spring –第3部分

最新推荐文章于 2022-03-22 15:02:24 发布
最新推荐文章于 2022-03-22 15:02:24 发布
阅读量259 收藏
点赞数
文章标签： java entity opera 莫比乌斯反演 log4j2
本文是本系列的最后一篇。 看一下第1 部分和第2部分 。

在本系列的最后一篇文章中，我将展示如何在JDK中使用本机JMX支持来实现一种通知机制，该机制可以在HEAP内存超过特定阈值时向侦听器发出警报。

正如我在上一篇文章中讨论的那样，这种方法是理想的，因为它是推式而不是拉式，不是侵入式的，并且对应用程序的计算需求最小。

这些是本文说明的解决方案的关键组件：

  • MemoryWarningService：此组件充当侦听器，并向Memory MBean注册其自身以接收通知。 可以使用介于0到1之间的百分比形式的阈值（其中1为100％）进行配置
  • MemoryThreadDumper：当通知MemoryWarningService HEAP使用量超过阈值并且其职责是将线程转储写入文件时，将调用此组件。
  • MemoryWarningServiceConfigurator：此组件是MBean，它公开一种用于更改MemoryWarningService阈值的方法。

该解决方案还提供用于在测试应用程序时填充HEAP的MemoryHeapFiller类和用于引导Spring环境的MemTest类。

当应用程序运行时（使用MemoryHeapFiller设置），您可以在URL上触发JConsole：service：jmx：rmi：// localhost / jndi / rmi：// localhost：8888 / jemosJmxConnector以jemosAdmin / secure连接并更改阈值各种价值。

该代码不是用于生产的：它不健壮，缺少许多注释，并且写入线程转储的文件名是硬编码的。 但是，它代表了一个很好的起点。

该代码附在下面。 您将需要Maven来构建它。

下载Jemos-jmx-experiments-0.0.1-SNAPSHOT-project

我尝试了一个初始阈值为0.5的场景，将其更改为0.3，然后更改为0.8。 结果如下所示： 

2011-08-15 21:53:21 ClassPathXmlApplicationContext [INFO] Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@a4a63d8: startup date [Mon Aug 15 21:53:21 BST 2011]; root of context hierarchy
2011-08-15 21:53:21 XmlBeanDefinitionReader [INFO] Loading XML bean definitions from class path resource [jemos-jmx-appCtx.xml]
2011-08-15 21:53:21 PropertyPlaceholderConfigurer [INFO] Loading properties file from class path resource [jemos-jmx.properties]
2011-08-15 21:53:21 PropertyPlaceholderConfigurer [INFO] Loading properties file from URL [file:/C:/Users/mtedone/.secure/jmxconnector-credentials.properties]
2011-08-15 21:53:21 ThreadPoolTaskScheduler [INFO] Initializing ExecutorService  'myScheduler'
2011-08-15 21:53:21 ClassPathXmlApplicationContext [INFO] Bean 'myScheduler' of type [class org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler] is not eligible for getting processed by all BeanPostProcessors (for example: not eligible for auto-proxying)
2011-08-15 21:53:21 DefaultListableBeanFactory [INFO] Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@30296f76: defining beans [propertyConfigurer,loggerConfigurator,memoryWarningServiceConfigurator,memoryHeapFiller,memoryThreadDumper,org.springframework.context.annotation.internalConfigurationAnnotationProcessor,org.springframework.context.annotation.internalAutowiredAnnotationProcessor,org.springframework.context.annotation.internalRequiredAnnotationProcessor,org.springframework.context.annotation.internalCommonAnnotationProcessor,mbeanExporter,jemosJmxServer,rmiRegistry,clientConnector,memoryMxBean,memoryWarningService,org.springframework.scheduling.annotation.internalAsyncAnnotationProcessor,org.springframework.scheduling.annotation.internalScheduledAnnotationProcessor,myScheduler]; root of factory hierarchy
2011-08-15 21:53:21 AnnotationMBeanExporter [INFO] Registering beans for JMX exposure on startup
2011-08-15 21:53:21 RmiRegistryFactoryBean [INFO] Looking for RMI registry at port '8888'
2011-08-15 21:53:23 RmiRegistryFactoryBean [INFO] Could not detect RMI registry - creating new one
2011-08-15 21:53:23 ConnectorServerFactoryBean [INFO] JMX connector server started: javax.management.remote.rmi.RMIConnectorServer@4355d3a3
2011-08-15 21:53:23 AnnotationMBeanExporter [INFO] Bean with name 'jemosJmxServer' has been autodetected for JMX exposure
2011-08-15 21:53:23 AnnotationMBeanExporter [INFO] Bean with name 'loggerConfigurator' has been autodetected for JMX exposure
2011-08-15 21:53:23 AnnotationMBeanExporter [INFO] Bean with name 'memoryWarningServiceConfigurator' has been autodetected for JMX exposure
2011-08-15 21:53:23 AnnotationMBeanExporter [INFO] Located managed bean 'loggerConfigurator': registering with JMX server as MBean [jemos.mbeans:type=config,name=LoggingConfiguration]
2011-08-15 21:53:23 AnnotationMBeanExporter [INFO] Located MBean 'jemosJmxServer': registering with JMX server as MBean [jemos.mbeans:name=jemosJmxServer,type=RMIConnectorServer]
2011-08-15 21:53:23 AnnotationMBeanExporter [INFO] Located managed bean 'memoryWarningServiceConfigurator': registering with JMX server as MBean [jemos.mbeans:type=config,name=MemoryWarningServiceConfiguration]
2011-08-15 21:53:23 MemoryWarningService [INFO] Percentage is: 0.5
2011-08-15 21:53:23 MemoryWarningService [INFO] Listener added to JMX bean
Adding data...
Adding data...
Adding data...
Adding data...
Adding data...
Adding data...
Adding data...
2011-08-15 21:53:37 MemoryWarningService [INFO] Percentage is: 0.3
2011-08-15 21:53:37 MemoryWarningServiceConfigurator [INFO] Memory threshold set to 0.3
Adding data...
2011-08-15 21:53:38 MemoryWarningService [WARN] Memory usage low!!!
2011-08-15 21:53:38 MemoryWarningService [WARN] percentageUsed = 0.3815679398794023
2011-08-15 21:53:38 MemoryThreadDumper [WARN] Stacks dumped to: C:/tmp/stacks.dump
Adding data...
Adding data...
Adding data...
2011-08-15 21:53:45 MemoryWarningService [INFO] Percentage is: 0.8
2011-08-15 21:53:45 MemoryWarningServiceConfigurator [INFO] Memory threshold set to 0.8
Adding data...
Adding data...
Adding data...
Adding data...
Adding data...
Adding data...
Adding data...
2011-08-15 21:54:01 MemoryWarningService [WARN] Memory usage low!!!
2011-08-15 21:54:01 MemoryWarningService [WARN] percentageUsed = 0.8383333266727508
2011-08-15 21:54:02 MemoryThreadDumper [WARN] Stacks dumped to: C:/tmp/stacks.dump
Adding data...
Adding data...
Adding data...
Exception in thread "JMX server connection timeout 24" java.lang.OutOfMemoryError: Java heap space

内存警告服务 

package uk.co.jemos.experiments.jmx;

import java.lang.management.ManagementFactory;
import java.lang.management.MemoryNotificationInfo;
import java.lang.management.MemoryPoolMXBean;
import java.lang.management.MemoryType;

import javax.annotation.PostConstruct;
import javax.management.Notification;
import javax.management.NotificationEmitter;
import javax.management.NotificationListener;

import org.springframework.beans.factory.annotation.Autowired;

/**
 * A component which sends notifications when the HEAP memory is above a certain
 * threshold.
 * 
 * @author mtedone
 * 
 */
public class MemoryWarningService implements NotificationListener {

    /** This bean's name */
    public static final String MBEAN_NAME = "jemos.mbeans:type=monitoring,name=MemoryWarningService";

    /** The application logger */
    private static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger
            .getLogger(MemoryWarningService.class);

    @Autowired
    private NotificationEmitter memoryMxBean;

    @Autowired
    private MemoryThreadDumper threadDumper;

    /** A pool of Memory MX Beans specialised in HEAP management */
    private static final MemoryPoolMXBean tenuredGenPool = findTenuredGenPool();

    /**
     * {@inheritDoc}
     */
    @Override
    public void handleNotification(Notification notification, Object handback) {

        if (notification.getType().equals(
                MemoryNotificationInfo.MEMORY_THRESHOLD_EXCEEDED)) {
            long maxMemory = tenuredGenPool.getUsage().getMax();
            long usedMemory = tenuredGenPool.getUsage().getUsed();
            LOG.warn("Memory usage low!!!");
            double percentageUsed = (double) usedMemory / maxMemory;
            LOG.warn("percentageUsed = " + percentageUsed);
            threadDumper.dumpStacks();

        } else {
            LOG.info("Other notification received..."
                    + notification.getMessage());
        }

    }

    /**
     * It sets the threshold percentage.
     * 
     * @param percentage
     */
    public void setPercentageUsageThreshold(double percentage) {
        if (percentage <= 0.0 || percentage > 1.0) {
            throw new IllegalArgumentException("Percentage not in range");
        } else {
            LOG.info("Percentage is: " + percentage);
        }
        long maxMemory = tenuredGenPool.getUsage().getMax();
        long warningThreshold = (long) (maxMemory * percentage);
        tenuredGenPool.setUsageThreshold(warningThreshold);
    }

    @PostConstruct
    public void completeSetup() {
        memoryMxBean.addNotificationListener(this, null, null);
        LOG.info("Listener added to JMX bean");
    }

    /**
     * Tenured Space Pool can be determined by it being of type HEAP and by it
     * being possible to set the usage threshold.
     */
    private static MemoryPoolMXBean findTenuredGenPool() {
        for (MemoryPoolMXBean pool : ManagementFactory.getMemoryPoolMXBeans()) {
            // I don't know whether this approach is better, or whether
            // we should rather check for the pool name "Tenured Gen"?
            if (pool.getType() == MemoryType.HEAP
                    && pool.isUsageThresholdSupported()) {
                return pool;
            }
        }
        throw new AssertionError("Could not find tenured space");
    }

}

内存线程转储器 

package uk.co.jemos.experiments.jmx;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

import org.apache.commons.io.IOUtils;
import org.springframework.stereotype.Component;

/**
 * This component dumps the thread stack to the file system.
 * 
 * @author mtedone
 * 
 */
@Component
public class MemoryThreadDumper {

    /** The application logger */
    private static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger
            .getLogger(MemoryThreadDumper.class);

    /**
     * It dumps the Thread stacks
     * 
     * @throws IOException
     */
    public void dumpStacks() {

        // hard-coded: This needs to be changed to a property or something
        String stackFileName = "C:/tmp/stacks.dump";

        ThreadMXBean mxBean = ManagementFactory.getThreadMXBean();
        ThreadInfo[] threadInfos = mxBean.getThreadInfo(
                mxBean.getAllThreadIds(), 0);
        Map<Long, ThreadInfo> threadInfoMap = new HashMap<Long, ThreadInfo>();
        for (ThreadInfo threadInfo : threadInfos) {
            threadInfoMap.put(threadInfo.getThreadId(), threadInfo);
        }

        File dumpFile = new File(stackFileName);
        BufferedWriter writer = null;
        try {
            writer = new BufferedWriter(new FileWriter(dumpFile));
            this.dumpTraces(mxBean, threadInfoMap, writer);

            LOG.warn("Stacks dumped to: " + stackFileName);

        } catch (IOException e) {
            throw new IllegalStateException(
                    "An exception occurred while writing the thread dump");
        } finally {
            IOUtils.closeQuietly(writer);
        }

    }

    private void dumpTraces(ThreadMXBean mxBean,
            Map<Long, ThreadInfo> threadInfoMap, Writer writer)
            throws IOException {
        Map<Thread, StackTraceElement[]> stacks = Thread.getAllStackTraces();
        writer.write("Dump of "
                + stacks.size()
                + " thread at "
                + new SimpleDateFormat("yyyy/MM/dd HH:mm:ss z")
                        .format(new Date(System.currentTimeMillis())) + "\n\n");
        for (Map.Entry<Thread, StackTraceElement[]> entry : stacks.entrySet()) {
            Thread thread = entry.getKey();
            writer.write("\"" + thread.getName() + "\" prio="
                    + thread.getPriority() + " tid=" + thread.getId() + " "
                    + thread.getState() + " "
                    + (thread.isDaemon() ? "deamon" : "worker") + "\n");
            ThreadInfo threadInfo = threadInfoMap.get(thread.getId());
            if (threadInfo != null) {
                writer.write("    native=" + threadInfo.isInNative()
                        + ", suspended=" + threadInfo.isSuspended()
                        + ", block=" + threadInfo.getBlockedCount() + ", wait="
                        + threadInfo.getWaitedCount() + "\n");
                writer.write("    lock=" + threadInfo.getLockName()
                        + " owned by " + threadInfo.getLockOwnerName() + " ("
                        + threadInfo.getLockOwnerId() + "), cpu="
                        + mxBean.getThreadCpuTime(threadInfo.getThreadId())
                        / 1000000L + ", user="
                        + mxBean.getThreadUserTime(threadInfo.getThreadId())
                        / 1000000L + "\n");
            }
            for (StackTraceElement element : entry.getValue()) {
                writer.write("        ");
                writer.write(element.toString());
                writer.write("\n");
            }
            writer.write("\n");
        }
    }

}

内存服务配置MBean 

package uk.co.jemos.experiments.jmx.mbeans;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.jmx.export.annotation.ManagedOperation;
import org.springframework.jmx.export.annotation.ManagedOperationParameter;
import org.springframework.jmx.export.annotation.ManagedOperationParameters;
import org.springframework.jmx.export.annotation.ManagedResource;
import org.springframework.stereotype.Component;

import uk.co.jemos.experiments.jmx.MemoryWarningService;

@Component
@ManagedResource(objectName = MemoryWarningServiceConfigurator.MBEAN_NAME, //
description = "Allows clients to set the memory threshold")
public class MemoryWarningServiceConfigurator implements
        ApplicationContextAware {

    

    /** The application logger */
    private static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger
            .getLogger(MemoryWarningServiceConfigurator.class);

    public static final String MBEAN_NAME = "jemos.mbeans:type=config,name=MemoryWarningServiceConfiguration";

    private ApplicationContext ctx;

    @ManagedOperation(description = "Sets the memory threshold for the memory warning system")
    @ManagedOperationParameters({ @ManagedOperationParameter(description = "The memory threshold", name = "memoryThreshold"), })
    public void setMemoryThreshold(double memoryThreshold) {

        MemoryWarningService memoryWarningService = (MemoryWarningService) ctx
                .getBean("memoryWarningService");
        memoryWarningService.setPercentageUsageThreshold(memoryThreshold);

        LOG.info("Memory threshold set to " + memoryThreshold);
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext)
            throws BeansException {
        ctx = applicationContext;

    }


}

Spring配置 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:util="http://www.springframework.org/schema/util"
    xmlns:task="http://www.springframework.org/schema/task"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
        http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd">


    <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"  >
        <property name="locations">
            <list>
                <value>classpath:jemos-jmx.properties</value>
                <value>file:///${user.home}/.secure/jmxconnector-credentials.properties
                </value>
            </list>
        </property>
    </bean>

    <context:component-scan base-package="uk.co.jemos.experiments.jmx" />

    <context:mbean-export default-domain="jemos.mbeans" />

    <bean id="jemosJmxServer" class="org.springframework.jmx.support.ConnectorServerFactoryBean"       
        depends-on="rmiRegistry">
        <property name="objectName" value="connector:name=rmi" />
        <property name="serviceUrl"
            value="service:jmx:rmi://localhost/jndi/rmi://localhost:${jemos.jmx.rmi.port}/jemosJmxConnector" />
        <property name="environment">
            <!-- the following is only valid when the sun jmx implementation is used -->
            <map>
                <entry key="jmx.remote.x.password.file" value="${user.home}/.secure/jmxremote.password" />
                <entry key="jmx.remote.x.access.file" value="${user.home}/.secure/jmxremote.access" />
            </map>
        </property>
    </bean>

    <bean id="rmiRegistry" class="org.springframework.remoting.rmi.RmiRegistryFactoryBean">
        <property name="port" value="${jemos.jmx.rmi.port}" />
    </bean>

    <bean id="clientConnector" class="org.springframework.jmx.support.MBeanServerConnectionFactoryBean"       
        depends-on="jemosJmxServer">
        <property name="serviceUrl"
            value="service:jmx:rmi://localhost/jndi/rmi://localhost:${jemos.jmx.rmi.port}/jemosJmxConnector" />
        <property name="environment">
            <map>
                <entry key="jmx.remote.credentials">
                    <bean
                        factory-method="commaDelimitedListToStringArray">
                        <constructor-arg value="${jmx.username},${jmx.password}" />
                    </bean>
                </entry>
            </map>
        </property>
    </bean>


    <bean id="memoryMxBean" class="java.lang.management.ManagementFactory"
        factory-method="getMemoryMXBean" />
        
    <bean id="memoryWarningService" class="uk.co.jemos.experiments.jmx.MemoryWarningService">
      <property name="percentageUsageThreshold" value="0.5" />
    </bean>
        

    <task:annotation-driven scheduler="myScheduler" />   

    <task:scheduler id="myScheduler" pool-size="10" />    
        


</beans>

参考： JMX和Spring –我们的JCG合作伙伴 Marco Tedone的第3部分 ，位于Marco Tedone的博客博客中。


翻译自: https://www.javacodegeeks.com/2012/07/jmx-and-spring-part-3.html

dnc8371
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
jmeter中timeout值怎么设置_Tomcat server.xml中配置的connectionTimeout参数无效？
weixin_42282116的博客
01-16 1066
在tomcat的配置文件server.xml中，可以设置Connector的参数，其中包含超时参数connectionTimeout。本人对其中几个重要参数大致理解为(应该理解错了)：connectionTimeout：一个请求最多等待时间，超过则报错。maxConnections：最多同时连接数，连接上不一定处理。超过连接数，则排队。maxThreads：同时处理的线程数，经测试，理解无误。ac...
Spring boot 在tomcat上部署 遇见 'JMX' server connection timeout 问题
MysticalRzc的博客
01-12 6385
最近搭了一个SpringBoot的项目，项目使用Spring+JPA项目很简单，但是部署到云服务器的时候可是废了一番周折。 显示给报了个 JMX错误，一查是线程互锁。？？？啥？匪夷所思，一个单线程的程序给我报线程互锁。后来找同事才解决，原来Spring Boot项目部署在tomcat上的时候需要实现一个接口，要不然tomcat不能够正常识别。这个接口就是 SpringBootServletI
TongWeb的JMX线程过多
web的博客
11-13 1298
通过JMX采集TongWeb监控值后，长时间运行导致JMX线程不断增加，导致OutOfMemoryError：unable to create new native thread异常。 通过jstack命令分析主要是JMX的server线程越来越多，而不退出。 JMX server connection timeout 207874&quot; daemon prio=10 tid=0x00007f709474c000 nid=0x457b in Object.wait() [0x00007f.
远程访问JMX遇到连接不上的问题（JConsole和VisualVM工具类似）
can_do_it的专栏
09-30 3406
java.rmi.ConnectException: Connection refused to host: 10.88.112.165; nested exception is: java.net.ConnectException: Connection timed out: connect at sun.rmi.transport.tcp.TCPEndpoint.newSocket(T...
Java多线程死锁例子
Davis
03-04 532
目录一、产生死锁的原因二、如何避免死锁 一、产生死锁的原因 发生死锁的情况： 多个线程需要同时占用多个共享资源而发生需要互相死循环等待的情况，就是，两个线程互相等待着对象释放锁，一直这样僵持下去，所以导致了死锁的产生。 产生死锁代码： package com.javaagent.thread; public class DieThread implements Runnable { p...
JDK自带JVM分析工具详解
热门推荐
靖节先生的博客
03-22 1万+
JDK自带JVM分析工具详解1. JVM分析工具概述1.1 JVM分析工具简介1.2 JVM分析工具分类2. JVM分析工具详解2.1 idea环境配置2.2 jps2.3 jinfo2.4 jvisualvm2.5 jconsole2.6 jstat2.7 jstack2.8 jcmd2.9 jmap 1. JVM分析工具概述 1.1 JVM分析工具简介 在日常应用开发过程中对JVM状态指标等健康状况的分析是必不可少的操作，尤其是在出现一些内存，GC，线程等问题，JVM分析工具能够很好的帮助我们定位分析问
JMX与Spring 结合
11-14
**JMX与Spring结合** 的主要目的是让Spring应用可以被远程管理和监控。下面我们将详细介绍几个关键点： 1. **JMX与Spring 结合实例**：在Spring应用中，可以通过配置或者编程方式来注册MBeans（Managed Beans），...
扩展Spring的JMX支持
02-04
Spring框架将体系结构依赖性降至最低，并且将应用程序中得组成部分进行了具体化，但是应用程序仍然是需要管理的。幸运的是，Spring1.2包括高级的JMX集成支持，并且JMX为应用程序提供了一种实用的管理基础架构。在...
基于Spring+JMX+Tomcat实现资源动态管理
07-27
3. 使用Spring的JMX支持：Spring提供了`PlatformMBeanServerBeanPostProcessor`，它可以自动检测带有MBean注解的bean并将其注册到MBean服务器。 4. 连接和管理：通过JConsole或其他JMX客户端工具，如VisualVM或JMC...
JMX SPRING
03-22
在Spring框架中，JMX被用来管理和监控Spring应用上下文中的bean和其他资源。通过JMX，我们可以暴露应用程序的关键指标，如内存使用情况、线程状态、系统属性等，以便进行远程管理和故障排查。 **Spring对JMX的支持*...
springcloud混沌测试-demo.jmx
04-22
springcloud混沌测试-demo.jmx
Spring Boot 2.+的默认连接池HikariCP详解
辰小白
03-26 5859
一、Spring Boot 2.+默认连接池HikariCP 如果是Spring Boot2.+,那么默认的连接池就是Hikaricp，不需要再另外导入包和配置，怎么证明？启动项目，可以看到控制台 启动信息HikariPool 启动信息HikariDataSource 我们在控制台看到了 HikariPool-1 - Starting... HikariPool-1 - Sta...
多线程阻塞问题的监控与调试
rogerxp的专栏
03-24 3811
最近，因为工作需要，做了个基于Applet的多文件上传的上传组件。简要介绍一下上传组件的原理：提交上传的每个文件作为一个客户端线程与服务器交互，同时每个文件上传线程对应一个读取服务端响应的服务线程，所有客户端线程都通过Applet主线程启动。由于整个组件的代码量较大这里不便于贴出来，我把问题以及解决问题的思路贴出来，这样也算是对自己前段时间的研究成果做一个总结，这样也为自己和后来人提供一个解决此类
Java多线程开发系列-线程活性故障
昕友软件博客
03-18 402
由资源稀缺性或者程序自身的问题和缺陷导致线程一直处于非Runnable状态，或者线程虽然处于Runnable状态但是其要执行的任务却一直无法进展的故障现象。 有4种情况 死锁 锁死 饥饿 活锁 死锁 如果线程A持有锁L并且想获得锁M，线程B持有锁M并且想获得锁L，那么这两个线程将永远等待下去，这种情况就是最简单的死锁形式。在数据库系统的设计中考虑了监测死锁以及从死锁中恢复，数据库如果...
用JMX调试Java应用程序
fanrey123的博客
07-06 436
如果不用jconsole，我们也可以直接用JMX来编程实现jconsole的所有功能。 1. Java应用启动时增加下面的参数： -Dcom.sun.management.jmxremote.port=6789 -Dcom.sun.management.jmxremote.authenticate=false -Dcom.sun.management.jmxremote.ssl=fa...
Jmeter Connection timed out: connect和500 Internal Server Error的错误，怎么解决？
caicai_L的博客
09-06 5031
Jmeter Connection timed out: connect和500 Internal Server Error的错误 java.net.ConnectException: Connection timed out: connect at java.net.DualStackPlainSocketImpl.connect0(Native Method) at java.net.Du...
【java】死锁产生分析与检测分析工具
XYZ
09-25 1452
最近在看了一些关于多线程死锁分析的博客，在死锁的分析方面有了一点自己的经验，下面将它总结记录下来。 1. 死锁简介 1.1 死锁的产生 1.2 线程 1.3 锁 2. 死锁举例 3. 死锁分析 3.1 VisualVM简介 3.2 VisualVM中插件安装 3.3 线程监视 3.4线程dump分析 3.5 Dump内容分析 3.6 利用Thread Dumps Anal...
(在线等。。。)这是出现死锁了吗 ？
weixin_34185320的博客
04-25 917
求大神解释下。。。 java.net.SocketTimeoutException: Read timed out at java.net.SocketInputStream.socketRead0(Native Method) at java.net.SocketInputStream.read(SocketInputStream...
windows下 的 jvisualvm,jstack参数查看运行程序的线程状况。
gottawangzi的博客
08-21 4405
今天在复习多线程的时候写了一个死锁，突然看到网上有人用jstack的命令参数可以查看程序中每个线程的运行情况，于是就尝试着自己动手操作了一下。在cmd下运行jstack -h  看到图中有一个jstack中所有的命令后面都要接上一个pid（进程id，就是我们运行程序的id）。但是这个我不知道啊。于是又去网上找了一些博客看了一下。发现了jvisualvm这个参数，抱着试试看的心里。在dos命令...
[课堂课件讲解]Java微服务实践-Spring Boot 监管.pptx
最新发布
08-27
该课件中涵盖了JMX的核心API、JMX客户端、JMX Spring Boot整合等议题，并对JMX的规范、优势和架构概况进行了详细介绍。 JMX作为Java平台的一部分，从Java 5开始得到支持，并随后的Java版本也都陆续加入了相关的JMX...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值