精华内容
下载资源
问答
  • 2021-05-08 22:31:54

    原文以下:linux

    linux本地检测如何tomcat是否启动成功?

    解决方法:

    1.curl 127.0.0.1:8080

    第一能够知道本地是否能够访问tomcat,返回页面代码

    2.tail -f ./catalina.out

    查看tomcat的logs目录下的catalina.out文件,看到末尾有

    22-Jun-2018 12:39:50.343 INFO [main] org.apache.catalina.startup.Catalina.start Server startup in 240280 ms,说明启动成功。

    3.ps -ef|grep tomcat

    若是返回一大串东西,说明tomcat启动成功。root 4479 1 0 12:35 pts/0 00:00:05 /usr/local/java/jdk1.8.0_162/bin/java -Djava.util.logging.config.file=/usr/local/apache-tomcat-8.5.31/conf/logging.properties -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Djdk.tls.ephemeralDHKeySize=2048 -Djava.protocol.handler.pkgs=org.apache.catalina.webresources -Dorg.apache.catalina.security.SecurityListener.UMASK=0027 -Dignore.endorsed.dirs= -classpath /usr/local/apache-tomcat-8.5.31/bin/bootstrap.jar:/usr/local/apache-tomcat-8.5.31/bin/tomcat-juli.jar -Dcatalina.base=/usr/local/apache-tomcat-8.5.31 -Dcatalina.home=/usr/local/apache-tomcat-8.5.31 -Djava.io.tmpdir=/usr/local/apache-tomcat-8.5.31/temp org.apache.catalina.startup.Bootstrap start

    4.jps -v 结果中21702 Bootstrap表明有java程序的pid是21702

    [root@VM_0_4_centos bin]# jps -v

    21718 Jps -Denv.class.path=.:/usr/local/java/jdk1.8.0_192/lib:/usr/local/java/jdk1.8.0_192/jre/lib -Dapplication.home=/usr/local/java/jdk1.8.0_192 -Xms8m

    21702 Bootstrap -Djava.util.logging.config.file=/usr/local/java/tomcat8/conf/logging.properties -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Djdk.tls.ephemeralDHKeySize=2048 -Djava.protocol.handler.pkgs=org.apache.catalina.webresources -Dorg.apache.catalina.security.SecurityListener.UMASK=0027 -Dignore.endorsed.dirs= -Dcatalina.base=/usr/local/java/tomcat8 -Dcatalina.home=/usr/local/java/tomcat8 -Djava.io.tmpdir=/usr/local/java/tomcat8/temp

    本文地址:http://www.yayihouse.com/yayishuwu/chapter/1310

    更多相关内容
  • 如何测试Tomcat是否启动成功

    千次阅读 2022-03-30 08:40:38
    (1)打开安装Tomcat的目录,在Tomcat文件夹下找到bin目录,双击startup.bat脚本文件启动Tomcat,如图所示: (2)同时按下“Win+R”键,然后在弹出的对话框中输入“cmd”并按回车键。在命令提示符界面中输入...

    今天教给大家Tomcat的两种打开方式和两种检测方法。
    1、打开方式
    (1)打开安装Tomcat的目录,在Tomcat文件夹下找到bin目录,双击startup.bat脚本文件启动Tomcat,如图所示:
    在这里插入图片描述
    在这里插入图片描述
    (2)同时按下“Win+R”键,然后在弹出的对话框中输入“cmd”并按回车键。在命令提示符界面中输入“startup”并回车,同样可以打开Tomcat。如图所示:
    在这里插入图片描述
    2、检测方法
    (1)不要关闭刚刚启动的Tomcat,打开浏览器在地址栏输入“localhost:8080”回车,出现Apache Tomcat主页说明Tomcat已经成功启动。如图:
    在这里插入图片描述
    (2)不要关闭刚刚启动的Tomcat,打开浏览器在地址栏输入“127.0.0.1:8080”回车,出现Apache Tomcat主页说明Tomcat已经成功启动。如图:
    在这里插入图片描述

    想得太多只会毁了你。让你陷入忐忑,让实际上本不糟糕的事情,变得糟糕。

    展开全文
  • springboot启动流程和Tomcat启动springboot启动函数新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、...

    1.springboot启动函数

    springboot启动函数如下所示:

    @SpringBootApplication(scanBasePackages = {"TestLab.JustTalk_Server", "TestLab.JustTalk_Common"})
    public class JustTalkServerApplication {
    
    	public static void main(String[] args) {
    		SpringApplication.run(JustTalkServerApplication.class, args);
    	}
    
    }
    

    主要包含两个个部分:

    1. 注解@SpringBootApplication
    2. SpringApplication.run()方法

    2.注解@SpringBootApplication

    让我们点进@SpringBootApplication

    @Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @SpringBootConfiguration
    @EnableAutoConfiguration
    @ComponentScan(
        excludeFilters = {@Filter(
        type = FilterType.CUSTOM,
        classes = {TypeExcludeFilter.class}
    ), @Filter(
        type = FilterType.CUSTOM,
        classes = {AutoConfigurationExcludeFilter.class}
    )}
    )
    public @interface SpringBootApplication {
    }
    

    可以看出来,其主要作用的是如下三个注解

    1. @SpringBootConfiguration
    2. @EnableAutoConfiguration
    3. @ComponentScan
      让我们分别看一下这三个注解有什么作用

    2.1@SpringBootConfiguration

    @Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Configuration
    @Indexed
    public @interface SpringBootConfiguration {
        @AliasFor(
            annotation = Configuration.class
        )
        boolean proxyBeanMethods() default true;
    }
    

    可见与@SpringBootConfiguration和@Configuration功能相同,标注当前类是配置类。

    2.2 @EnableAutoConfiguration

    @Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @AutoConfigurationPackage
    @Import({AutoConfigurationImportSelector.class})
    public @interface EnableAutoConfiguration {
        String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
    
        Class<?>[] exclude() default {};
    
        String[] excludeName() default {};
    }
    

    在上面一串注解中起重要作用的是@AutoConfigurationPackage和@Import({AutoConfigurationImportSelector.class})
    @Import()可以直接指定实体类,加载这个类定义到context中。

    @Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @Import({Registrar.class})
    public @interface AutoConfigurationPackage {
        String[] basePackages() default {};
    
        Class<?>[] basePackageClasses() default {};
    }
    

    如上可见,@AutoConfigurationPackage借助Registrar.class完成注册,通过getPackageNames注册当前启动类的根package

        static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
            Registrar() {
            }
    
            public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
                AutoConfigurationPackages.register(registry, (String[])(new AutoConfigurationPackages.PackageImports(metadata)).getPackageNames().toArray(new String[0]));
            }
        }
    

    接下来是AutoConfigurationImportSelector类,紧接着会调用其中的selectImports方法。

    public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
        public String[] selectImports(AnnotationMetadata annotationMetadata) {
            if (!this.isEnabled(annotationMetadata)) {
                return NO_IMPORTS;
            } else {
                AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(annotationMetadata);
                return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
            }
        }
    }
    

    selectImports会返回autoConfigurationEntry.getConfigurations()然后通过
    getCandidateConfigurations->SpringFactoriesLoader.loadFactoryNames最终从META-INF/spring.factories中加载配置类

    Enumeration urls = classLoader.getResources("META-INF/spring.factories");
    

    2.3 @ComponentScan

    @Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.TYPE})
    @Documented
    @Repeatable(ComponentScans.class)
    public @interface ComponentScan {
    }
    

    @ComponentScan注解相信很多人都知道它的作用,也就是指定扫描的范围,加载该范围内的bean和context等,默认扫描路径为声明@ComponentScan所在类的package。可以通过scanBasePackages = {“XXX”, “XXX”}来指定需要扫描的包。

    3 SpringApplication.run

    SpringApplication.run是一个静态方法,但最终会创建一个SpringApplication去调用run方法

    //1
        public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
            return run(new Class[]{primarySource}, args);
        }
    //2
        public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
            return (new SpringApplication(primarySources)).run(args);
        }
    
        public static void main(String[] args) throws Exception {
            run(new Class[0], args);
        }
     //3 调用构造器
         public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
            this.sources = new LinkedHashSet();
            this.bannerMode = Mode.CONSOLE;
            this.logStartupInfo = true;
            this.addCommandLineProperties = true;
            this.addConversionService = true;
            this.headless = true;
            this.registerShutdownHook = true;
            this.additionalProfiles = Collections.emptySet();
            this.isCustomEnvironment = false;
            this.lazyInitialization = false;
            this.applicationContextFactory = ApplicationContextFactory.DEFAULT;
            this.applicationStartup = ApplicationStartup.DEFAULT;
            this.resourceLoader = resourceLoader;
            Assert.notNull(primarySources, "PrimarySources must not be null");
            this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
            this.webApplicationType = WebApplicationType.deduceFromClasspath();
            this.bootstrapRegistryInitializers = new ArrayList(this.getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
            this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
            this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
            this.mainApplicationClass = this.deduceMainApplicationClass();
        }
        //4 run
    public ConfigurableApplicationContext run(String... args) {
        //创建计时器
        StopWatch stopWatch = new StopWatch();
        //开始计时
        stopWatch.start();
        //定义上下文对象
        ConfigurableApplicationContext context = null;
        Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
        //Headless模式设置
        configureHeadlessProperty();
        //加载SpringApplicationRunListeners监听器
        SpringApplicationRunListeners listeners = getRunListeners(args);
        //发送ApplicationStartingEvent事件
        listeners.starting();
        try {
            //封装ApplicationArguments对象
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
            //配置环境模块
            ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
            //根据环境信息配置要忽略的bean信息
            configureIgnoreBeanInfo(environment);
            //打印Banner标志
            Banner printedBanner = printBanner(environment);
            //创建ApplicationContext应用上下文
            context = createApplicationContext();
            //加载SpringBootExceptionReporter
            exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
                                                             new Class[] { ConfigurableApplicationContext.class }, context);
            //ApplicationContext基本属性配置
            prepareContext(context, environment, listeners, applicationArguments, printedBanner);
            //刷新上下文
            refreshContext(context);
            //刷新后的操作,由子类去扩展
            afterRefresh(context, applicationArguments);
            //计时结束
            stopWatch.stop();
            //打印日志
            if (this.logStartupInfo) {
                new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
            }
            //发送ApplicationStartedEvent事件,标志spring容器已经刷新,此时所有的bean实例都已经加载完毕
            listeners.started(context);
            //查找容器中注册有CommandLineRunner或者ApplicationRunner的bean,遍历并执行run方法
            callRunners(context, applicationArguments);
        }
        catch (Throwable ex) {
            //发送ApplicationFailedEvent事件,标志SpringBoot启动失败
            handleRunFailure(context, ex, exceptionReporters, listeners);
            throw new IllegalStateException(ex);
        }
    
        try {
            //发送ApplicationReadyEvent事件,标志SpringApplication已经正在运行,即已经成功启动,可以接收服务请求。
            listeners.running(context);
        }
        catch (Throwable ex) {
            //报告异常,但是不发送任何事件
            handleRunFailure(context, ex, exceptionReporters, null);
            throw new IllegalStateException(ex);
        }
        return context;
    }
    
    

    在创建SpringApplication的构造器中做的事如下所述:

    在这里插入图片描述
    接下来在调用的run方法中执行流程如图所示:
    在这里插入图片描述

    最终完成springboot的完整启动过程

    4 TOMCAT的启动

    想要知道springboot是怎样启动Tomcat服务的就需要关注上一节中第4步执行的run方法,在其中执行了createApplicationContext方法创建上下文。
    createApplicationContext

    //创建上下文
        protected ConfigurableApplicationContext createApplicationContext() {
            return this.applicationContextFactory.create(this.webApplicationType);
        }
    
    
    	public interface ApplicationContextFactory {
    	    ApplicationContextFactory DEFAULT = (webApplicationType) -> {
    	        try {
    	            switch(webApplicationType) {
    	            case SERVLET:
    	                return new AnnotationConfigServletWebServerApplicationContext();
    	            case REACTIVE:
    	                return new AnnotationConfigReactiveWebServerApplicationContext();
    	            default:
    	                return new AnnotationConfigApplicationContext();
    	            }
    	        } catch (Exception var2) {
    	            throw new IllegalStateException("Unable create a default ApplicationContext instance, you may need a custom ApplicationContextFactory", var2);
    	        }
    	    };
    	    //创建
    	    ConfigurableApplicationContext create(WebApplicationType webApplicationType);
    
    	}
    

    spring根据webApplicationType创建AnnotationConfigServletWebServerApplicationContext类,创建上下文。
    接下来的prepareContext方法会运行一些初始化的流程,然后会注册一些spring boot启动所需要的bean,加载一些初始的beans。

    refreshContext(context);
    从refreshContext一直深入,最终会调用AbstractApplicationContext中的refresh方法,refresh方法是spring中管理bean的核心方法

    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // 忽略掉不重要!启动阶段标记,初始化时标记位为false,执行refresh完毕后修改为true(最后的end方法).
            StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
    
            // 1. 准备刷新上下文方法,用于设置准备刷新前的一些参数:
            //  程序启动标志位/上下文拓展资源加载/上下文环境准备情况验证/监听器监听事件容器初始化准备
            prepareRefresh();
    
            // 2. 获取BeanFactory,内部调用refreshBeanFactory()和getBeanFactory()均由子类实现
            //  告知子类刷新Bean工厂(设置序列号ID--> 参考GenericApplicationContext)
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
            // 3. 初始化Bean工厂,设置基础属性: ClassLoader、SPEL(SPring表达式)解析器、属性编辑器(自定义属性覆盖默认属性)、
            //  添加系统BeanPostProcessor`ResourceEditorRegistrar(初始化前执行一些Aware即invokeAwareInterfaces方法)`、
            //  忽略一些系统级接口装配依赖、注入一些不能自动创建的Bean依赖(Bean工厂,ResourceLoader(加载资源文件),事件发布类,上下文)、
            //  加系统BeanPostProcessor`ApplicationListenerDetector(Bean初始化后执行,判断是否是单例监听器加到上下文中)`、
            //  加入AspectJ静态代理支持、系统环境Bean检查注册
            prepareBeanFactory(beanFactory);
    
            try {
                // 4. BeanFactory配置好的后置拓展操作.由子类拓展.可在这里提前加入自定义BeanFactoryPostProcess
                postProcessBeanFactory(beanFactory);
    
                // 忽略掉不重要!启动阶段标记
                StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
                // 5. 执行BeanFactory后置处理. Spring的SPI机制保障(可看我自动装载文章).
                invokeBeanFactoryPostProcessors(beanFactory);
    
                // 6. 注册BeanPostProcessors到BeanFacotry中并排序,并未执行.涉及到Bean生命周期执行
                registerBeanPostProcessors(beanFactory);
                beanPostProcess.end();
    
                // 7. 初始化MessageSource,用于消息国际化处理
                initMessageSource();
    
                // 8. 初始化上下文事件广播器
                initApplicationEventMulticaster();
    
                // 9. 子类实现,springbootstarterweb在此创建web容器,并提前生成容器所需的Bean及其对应生命周期
                onRefresh();
    
                // 10. 给广播器中注册监听器,执行初期事件
                registerListeners();
    
                // 11. 初始化所有非懒加载单例Bean
                finishBeanFactoryInitialization(beanFactory);
    
                // 12. 完成刷新,发布上下文刷新完毕事件
                finishRefresh();
            }catch (BeansException ex) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Exception encountered during context initialization - " +
                            "cancelling refresh attempt: " + ex);
                }
                // 刷新异常,销毁已经创建的Bean
                destroyBeans();
                // 取消刷新,设置active为false
                cancelRefresh(ex);
                // Propagate exception to caller.
                throw ex;
            }finally {
                // Reset common introspection caches in Spring's core, since we
                // might not ever need metadata for singleton beans anymore...
    
                resetCommonCaches();
                // 刷新结束,设置标志位为true
                contextRefresh.end();
            }
        }
    }
    

    我们可以看出在其中的onrefresh方法中创建了createWebServer

        protected void onRefresh() {
            super.onRefresh();
    
            try {
                this.createWebServer();
            } catch (Throwable var2) {
                throw new ApplicationContextException("Unable to start reactive web server", var2);
            }
        }
        
        private void createWebServer() {
            WebServerManager serverManager = this.serverManager;
            if (serverManager == null) {
                StartupStep createWebServer = this.getApplicationStartup().start("spring.boot.webserver.create");
                String webServerFactoryBeanName = this.getWebServerFactoryBeanName();
                ReactiveWebServerFactory webServerFactory = this.getWebServerFactory(webServerFactoryBeanName);
                createWebServer.tag("factory", webServerFactory.getClass().toString());
                boolean lazyInit = this.getBeanFactory().getBeanDefinition(webServerFactoryBeanName).isLazyInit();
                this.serverManager = new WebServerManager(this, webServerFactory, this::getHttpHandler, lazyInit);
                this.getBeanFactory().registerSingleton("webServerGracefulShutdown", new WebServerGracefulShutdownLifecycle(this.serverManager.getWebServer()));
                this.getBeanFactory().registerSingleton("webServerStartStop", new WebServerStartStopLifecycle(this.serverManager));
                createWebServer.end();
            }
    
            this.initPropertySources();
        }
    

    继续追踪WebServerManager方法

        WebServerManager(ReactiveWebServerApplicationContext applicationContext, ReactiveWebServerFactory factory, Supplier<HttpHandler> handlerSupplier, boolean lazyInit) {
            this.applicationContext = applicationContext;
            Assert.notNull(factory, "Factory must not be null");
            this.handler = new WebServerManager.DelayedInitializationHttpHandler(handlerSupplier, lazyInit);
            this.webServer = factory.getWebServer(this.handler);
        }
    
    	@FunctionalInterface
    	public interface ReactiveWebServerFactory {
        	WebServer getWebServer(HttpHandler httpHandler);
    	}
    

    进入接口getWebServer,在这里接口ReactiveWebServerFactory 有多个实现类
    在这里插入图片描述
    此时我们进入Tomcat实现类中

        public WebServer getWebServer(HttpHandler httpHandler) {
        
            Connector connector = new Connector(this.protocol);
            connector.setThrowOnFailure(true);
            tomcat.getService().addConnector(connector);
            this.customizeConnector(connector);
            tomcat.setConnector(connector);
            tomcat.getHost().setAutoDeploy(false);
            this.configureEngine(tomcat.getEngine());
    
    		TomcatHttpHandlerAdapter servlet = new TomcatHttpHandlerAdapter(httpHandler);
            this.prepareContext(tomcat.getHost(), servlet);
            return this.getTomcatWebServer(tomcat);
        }
    

    可以看到其中创建了connector 对象和Engine容器。
    getTomcatWebServer
    getTomcatWebServer中创建了TomcatWebServer对象,然后调用initialize方法完成初始化。在initialize中

        protected TomcatWebServer getTomcatWebServer(Tomcat tomcat) {
            return new TomcatWebServer(tomcat, this.getPort() >= 0, this.getShutdown());
        }
        
        public TomcatWebServer(Tomcat tomcat, boolean autoStart, Shutdown shutdown) {
            this.monitor = new Object();
            this.serviceConnectors = new HashMap();
            Assert.notNull(tomcat, "Tomcat Server must not be null");
            this.tomcat = tomcat;
            this.autoStart = autoStart;
            this.gracefulShutdown = shutdown == Shutdown.GRACEFUL ? new GracefulShutdown(tomcat) : null;
            this.initialize();
        }
        //initialize方法
        private void initialize() throws WebServerException {
            logger.info("Tomcat initialized with port(s): " + this.getPortsDescription(false));
            synchronized(this.monitor) {
                try {
                    this.addInstanceIdToEngineName();
                    Context context = this.findContext();
                    context.addLifecycleListener((event) -> {
                        if (context.equals(event.getSource()) && "start".equals(event.getType())) {
                            this.removeServiceConnectors();
                        }
    
                    });
                    //启动服务
                    this.tomcat.start();
                    this.rethrowDeferredStartupExceptions();
    
                    try {
                        ContextBindings.bindClassLoader(context, context.getNamingToken(), this.getClass().getClassLoader());
                    } catch (NamingException var5) {
                    }
    
                    this.startDaemonAwaitThread();
                } catch (Exception var6) {
                    this.stopSilently();
                    this.destroySilently();
                    throw new WebServerException("Unable to start embedded Tomcat", var6);
                }
    
            }
        }
    

    在tomcat.start方法中完成Tomcat服务的启动

    @Override
    public void start() throws WebServerException {
    	synchronized (this.monitor) {
    		if (this.started) {
    			return;
    		}
    		try {
    			addPreviouslyRemovedConnectors();
    			Connector connector = this.tomcat.getConnector();
    			if (connector != null && this.autoStart) {
    				performDeferredLoadOnStartup();
    			}
    			checkThatConnectorsHaveStarted();
    			this.started = true;
    			//在控制台打印这句日志,如果在yml设置了上下文,这里会打印
    			logger.info("Tomcat started on port(s): " + getPortsDescription(true) + " with context path '"
    					+ getContextPath() + "'");
    		}
    		catch (ConnectorStartFailedException ex) {
    			stopSilently();
    			throw ex;
    		}
    		catch (Exception ex) {
    			throw new WebServerException("Unable to start embedded Tomcat server", ex);
    		}
    		finally {
    			Context context = findContext();
    			ContextBindings.unbindClassLoader(context, context.getNamingToken(), getClass().getClassLoader());
    		}
    	}
    }
    

    参考链接:
    SpringBoot启动流程是怎样的?
    SPRINGBOOT启动流程及其原理
    SpringBoot内置tomcat启动原理
    AbstractApplicationContext.refresh()应用上下文刷新方法

    展开全文
  • 使用Intellij idea 其发动tomcat时会配置启动vm options :-Xms128m -Xmx768m -XX:PermSize=64M -XX:MaxPermSize=512m。但是这些参数到底是什么意思呢? 有时候参数设置大小会出现内存泄漏的问题:OOM(“Out of ...

    使用Intellij idea 其发动tomcat时会配置启动vm options :-Xms128m -Xmx768m -XX:PermSize=64M -XX:MaxPermSize=512m。

    但是这些参数到底是什么意思呢? 有时候参数设置大小会出现内存泄漏的问题:

    OOM(“Out of Memory”)异常一般主要有如下2种原因:

    1、 年老代溢出,表现为:java.lang.OutOfMemoryError:Javaheapspace

    这是最常见的情况,产生的原因可能是:设置的内存参数Xmx过小或程序的内存泄露及使用不当问题。

    例如循环上万次的字符串处理、创建上千万个对象、在一段代码内申请上百M甚至上G的内存。还有的时候虽然不会报内存溢出,却会使系统不间断的垃圾回收,也无法处理其它请求。这种情况下除了检查程序、打印堆内存等方法排查,还可以借助一些内存分析工具,比如MAT就很不错。

    2、 持久代溢出,表现为:java.lang.OutOfMemoryError:PermGenspace

    通常由于持久代设置过小,动态加载了大量Java类而导致溢出,解决办法唯有将参数 -XX:MaxPermSize 调大(一般256m能满足绝大多数应用程序需求)。将部分Java类放到容器共享区(例如Tomcat share lib)去加载的办法也是一个思路,但前提是容器里部署了多个应用,且这些应用有大量的共享类库。

    参数说明

    -Xmx3550m:设置JVM最大堆内存为3550M。

    -Xms3550m:设置JVM初始堆内存为3550M。此值可以设置与-Xmx相同,以避免每次垃圾回收完成后JVM重新分配内存。

    -Xss128k:设置每个线程的栈大小。JDK5.0以后每个线程栈大小为1M,之前每个线程栈大小为256K。应当根据应用的线程所需内存大小进行调整。在相同物理内存下,减小这个值能生成更多的线程。但是操作系统对一个进程内的线程数还是有限制的,不能无限生成,经验值在3000~5000左右。需要注意的是:当这个值被设置的较大(例如>2MB)时将会在很大程度上降低系统的性能。

    -Xmn2g:设置年轻代大小为2G。在整个堆内存大小确定的情况下,增大年轻代将会减小年老代,反之亦然。此值关系到JVM垃圾回收,对系统性能影响较大,官方推荐配置为整个堆大小的3/8。

    -XX:NewSize=1024m:设置年轻代初始值为1024M。

    -XX:MaxNewSize=1024m:设置年轻代最大值为1024M。

    -XX:PermSize=256m:设置持久代初始值为256M。

    -XX:MaxPermSize=256m:设置持久代最大值为256M。

    -XX:NewRatio=4:设置年轻代(包括1个Eden和2个Survivor区)与年老代的比值。表示年轻代比年老代为1:4。

    -XX:SurvivorRatio=4:设置年轻代中Eden区与Survivor区的比值。表示2个Survivor区(JVM堆内存年轻代中默认有2个大小相等的Survivor区)与1个Eden区的比值为2:4,即1个Survivor区占整个年轻代大小的1/6。

    -XX:MaxTenuringThreshold=7:表示一个对象如果在Survivor区(救助空间)移动了7次还没有被垃圾回收就进入年老代。如果设置为0的话,则年轻代对象不经过Survivor区,直接进入年老代,对于需要大量常驻内存的应用,这样做可以提高效率。如果将此值设置为一个较大值,则年轻代对象会在Survivor区进行多次复制,这样可以增加对象在年轻代存活时间,增加对象在年轻代被垃圾回收的概率,减少Full GC的频率,这样做可以在某种程度上提高服务稳定性。

    标准参数(-),所有JVM都必须支持这些参数的功能,而且向后兼容;例如:

    -client——设置JVM使用Client模式,特点是启动速度比较快,但运行时性能和内存管理效率不高,通常用于客户端应用程序或开发调试;在32位环境下直接运行Java程序默认启用该模式。

    -server——设置JVM使Server模式,特点是启动速度比较慢,但运行时性能和内存管理效率很高,适用于生产环境。在具有64位能力的JDK环境下默认启用该模式。

    非标准参数(-X),默认JVM实现这些参数的功能,但是并不保证所有JVM实现都满足,且不保证向后兼容;

    非稳定参数(-XX),此类参数各个JVM实现会有所不同,将来可能会不被支持,需要慎重使用;

    展开全文
  • Tomcat启动流程

    2020-04-14 17:11:17
    由于所有的组件均存在初始化、启动、停止等生命周期方法,拥有生命周期管理的特性, 所以Tomcat在设计的时候, 基于生命周期管理抽象成了一个接口 Lifecycle ,而组件 Server、Service、Container、Executor、...
  • 查看tomcat启动日志

    千次阅读 2021-05-18 20:14:46
    查看tomcat启动日志需要注意的是看清楚自己的安装目录,不一定是我小面写的。 1、先切换到:cd /usr/local/tomcat/apache-tomcat-8.5.41/logs/ 2、tail -f catalina.out 或者指定查多少行:tail -200 catalina.out 3...
  • 先在tomcat的bin目录下启动,测试:可以成功访问tom猫页面,证明:不是tomcat的问题。 解决方法: 1.修改eclipse的server中tomcat的time out,把值修改大一点,120或1000。 用debug模式启动tomcat, 如果...
  • 1、首先,进入Tomcat下的bin目录cd /usr/local/tomcat/bin2、查看Tomcat是否以关闭ps -ef|grep tomcat如果显示以下信息,说明Tomcat还没有关闭root 7010 1 0 Apr19 ? 00:30:13 /usr/local/java/bin/java-Djava.util....
  • 自己搭建了一个springMVC项目,中间出了一些问题,在排查问题的过程中发现eclipse成功启动Tomcat,但是在浏览器中输入localhost:8080却给我一个冷冷的404,我以为是Tomcat出问题了(心情大好,以为自己搭建的项目...
  • Linux下tomcat启动特别慢

    千次阅读 2020-08-15 10:18:30
    这两天由于公司有个新项目,所以在阿里云购买了一些新的服务器,环境搭建完成之后,启动tomcat的时候发现巨慢,有图有真相: 可以看到启动的毫秒数有多久… 分析 为了找出原因,首先打印日志,把log4j2的日志层级...
  • 你在开发Web应用时可以直接在本地像运行控制台应用一样启动,省去了重复部署的时间;配置上相比于SpringMVC也是有了大大的简化。SpringBoot的应用可以直接打成一个可运行的jar包, 你无需发愁为了不同应用要部署多个...
  • tomcat启动war包,tomcat配置详解
  • tomcat 嵌入式启动原理

    2021-12-14 00:12:11
    tomcat 嵌入式启动原理
  • ubuntu上tomcat 启动成功但访问不了

    千次阅读 2015-09-08 10:55:00
    2019独角兽企业重金招聘Python工程师标准>>> ...
  • 2019独角兽企业重金招聘Python工程师标准>>> ...
  • 1.首先tomcat版本不能小于boot内置的tomcat 2.把项目war打好的包放到tomcat的...3.启动tomcat 看这个标志代表你的war包没有问题,如果有报错请百度解决 4.访问测试 http://localhost:8088/war包的名字/接口路径 ...
  • 在Linux系统下,重启Tomcat使用命令的操作! 1.首先,进入Tomcat下的bin目录 cd /usr/local/tomcat/bin 使用Tomcat关闭命令 ./shutdown.sh 查看Tomcat是否以关闭 ps -ef|grep java 如果显示以下...
  • Tomcat启动nodejs服务

    2020-12-22 23:11:30
    我的目标是将war文件部署到Tomcat并让Tomcat启动我的REST服务 .请注意,这是Tomcat应用服务器,而不是Apache Web服务器,所以关于mod_proxy和.htaccess的所有帖子都不起作用 . 我知道节点不需要Tomcat,该节点不是...
  • 基于Java的Web 应用程序是 servlet、JSP 页面、静态页面、类和其他资源的集合,它们可以用标准方式打包,并运行在来自多个供应商的多个容器。Web 应用程序存在于结构化层次结构的目录中,该层次结构是由 Java ...
  • Tomcat启动流程到请求处理 说明: 使用的源码版本是tomcat 8.5 1. Tomcat 启动流程 1. Tomcat 源码目录 catalina 目录 catalina 包含所有的 Servlet 容器实现,以及涉及到安全、会话、集群、部署管理 Servlet ...
  • tomcat启动时没有把spring配置文件定义的bean加载进来 最近在把自己的之前搭建的那个通用的ssh框架,配置成dubbo+zookeeper这样的分布式架构。搭建的思路就是把项目的service和controller分离出来。两个项目之间的...
  • 启动tomcat服务,运行web项目

    千次阅读 2020-04-28 15:38:46
    安装目录下:tomcat/bin,如下,双击"Tomcat9.exe" 弹出窗口,不要关掉 浏览器打开:http://localhost:8080/ 如下页面代表启动成功
  • Tomcat启动参数总结

    千次阅读 2018-04-09 17:29:20
    目前见到的tomcat的一些使用参数,再遇到继续补充 -Xmx1g 设置tomcat的最大使用内存,32位系统因为系统原因有最大限制,64位系统则受限于计算机的物理内存。 -Xmx1g 设置tomcat的初始内存大小,此值可设置与-Xmx...
  • Linux服务器启动tomcat的三种方式

    千次阅读 2022-04-05 19:18:14
    直接进入主题,首先cd进入tomcat的bin文件夹下,然后可以尝试以下三种启动方式: 第一种(当前会话启动): ./startup.sh 效果: 然后tomcat就在后台启动了,我们还可以在当前会话中继续输入其它指令,比如 ps -ef...
  • 1.应用服务器设计 2.各个组件说明 3.tomcat请求处理
  • 在Linux系统下,重启Tomcat使用命令的操作! 1.首先,进入Tomcat下的bin目录 cd /usr/local/tomcat/bin 使用Tomcat关闭命令 ./shutdown.sh 查看Tomcat是否以关闭 ps -ef|grep java 如果显示以下相似信息,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 85,159
精华内容 34,063
关键字:

tomcat启动成功的标志