精华内容
下载资源
问答
  • 最近遇到一个很头疼的问题,发布到测试服务器的tomcat中跑的java应用,频繁无故停止,并且...下面是tomcat被kill掉的截图记录该看到记录后开始思考为什么tomcat应用的vm总内存可以达到7G之多,要知道我的服务器的...

    最近遇到一个很头疼的问题,发布到测试服务器的tomcat中跑的java应用,频繁无故停止,并且查询catalina.out日志中并没有tomcat停止的相应记录,后来在主机的/var/log/messages文件中发现了端倪,原来是被linux 的OOM kill掉了,下面是tomcat被kill掉的截图记录

    85ac4bdcb9ba

    看到记录后开始思考为什么tomcat应用的vm总内存可以达到7G之多,要知道我的服务器的总内存才8G,且其上还运行了其他的应用,首先想到的是发生了内存泄露,于是开始配置jvm参数,打开gc日志以及溢出记录,以下是我设置jvm启动参数(jdk8)

    vim tomcat8/bin/catalina.sh 文件最上面添加以下

    JAVA_OPTS='-Xms512m -Xmx512m -XX:MetaspaceSize=128m -XX:MaxDirectMemorySize=40m -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/wilson/dump -XX:+PrintGCDetails -Xloggc:/wilson/gc.log -XX:+PrintGCTimeStamps'

    参数解释:

    -Xms512m  初始化jvm堆内存大小

    -XmX512m  jvm堆内存最大值

    -XX:MetaspaceSize=128m  初始化元空间内存大小(此处由于我使用的是jdk1.8,官方改用元空间替换原来的持久代,默认对于64位的server vm该值的初始值为21m,在jvm启动时,一旦元空间的值达到21m,便会触发Full GC 去卸载没有用的类,然后该值的大小会重置,新值的大小将取决与 GC 后释放了多少元空间,若释放的空间不足,会充值并提升该值的大小,若释放的空间过多,则降低该值的大小,所以如果该值的初始化值过小,会导致在jvm启动时频繁的触发Full GC去调整,即会导致启动时间增加)

    -XX:MaxMetaspaceSize  最大元空间大小,默认没有上线,取决于主机的内存

    -XX:MaxDirectMemorySize=40m  最大nio堆外内存大小(注意该参数只是限制nio堆外内存,堆外内存占用还有其他的部分)

    -XX:+HeapDumpOnOutOfMemoryError 开启堆内存溢出生成dump文件

    -XX:HeapDumpPath=/wilson/dump  生成dump文件位置

    -XX:+PrintGCDetails  开启生成gc详细日志

    -Xloggc:/wilson/gc.log  gc文件日志

    -XX:+PrintGCTimeStamps  设置开启gc时间格式

    参数配置完毕重启tomcat,观察gc情况以及是否发生内存泄露

    启动完毕后,查询tomcat进程的pid :

    netstat -apn | grep

    再命令行输入: jmap -heap 可以查看jvm参数设置情况,以及简单的堆内存占用情况发现堆内存占用情况一直处于正常的水平中,通过gc.log文件看也是正常的,并且没有发生过内存泄露生成过dump文件,为此专门安装了可视化工具JProfiler

    那么,问题来了,究竟是什么原因引起的tomcat内存占用将近7个g的呢?继续往下看

    猜想可能是发生其他堆外内存泄露,导致tomcat占用内存飙升。分析堆外内存的话需要通过google-perftools分析了

    google-perftools安装连接:google-perftools安装

    安装完google-perftools之后,重启tomcat,持续观察其内存占用情况,未完待续......

    展开全文
  • 这种线程并不属于程序中不可或缺的部分,当所有的非守护线程结束时,程序也就终止了,同时会杀死进程中的所有守护线程。反过来说,只要任何非守护线程还在运行,程序就不会终止。 用户线程和守护线程两者几乎没有...

    在默认的配置下启动完之后会看到后台实际上总共有 6 个线程在运行。即 1 个用户线程,剩下 5 个为守护线程(下图中的 Daemon Thread )。

    如果对什么叫守护线程的概念比较陌生,这里再重复一下:

    所谓守护线程,是指在程序运行的时候在后台提供一种通用服务的线程,比如垃圾回收线程。这种线程并不属于程序中不可或缺的部分,当所有的非守护线程结束时,程序也就终止了,同时会杀死进程中的所有守护线程。反过来说,只要任何非守护线程还在运行,程序就不会终止。

    用户线程和守护线程两者几乎没有区别,唯一的不同之处就在于虚拟机的离开:如果用户线程已经全部退出运行了,只剩下守护线程存在了,虚拟机也就退出了。因为没有了被守护者,守护线程也就没有工作可做了,也就没有继续运行程序的必要了。将线程转换为守护线程可以通过调用 Thread 对象的 setDaemon(true) 方法来实现。

    Tomcat 的关闭正是利用了这个原理,即只要将那唯一的一个用户线程关闭,则整个应用就关闭了。

    要研究这个用户线程怎么被关闭的得先从这个线程从何产生说起。在前面分析 Tomcat 的启动时我们是从org.apache.catalina.startup.Bootstrap类的 main 方法作为入口,该类的 453 到 456 行是 Tomcat 启动时会执行的代码:

    前面的文章里分析了 daemon.load 和 daemon.start 方法,这里请注意

    daemon.setAwait(true);
    

    这句,它的作用是通过反射调用 

    org.apache.catalina.startup.Catalina
    

    类的 setAwait(true) 方法,最终将 Catalina 类的实例变量 await 设值为 true 。

    Catalina 类的 setAwait 方法代码:

    /**
     * Set flag.
     */
    public void setAwait(boolean await)
        throws Exception {
    
        Class<?> paramTypes[] = new Class[1];
        paramTypes[0] = Boolean.TYPE;
        Object paramValues[] = new Object[1];
        paramValues[0] = Boolean.valueOf(await);
        Method method =
            catalinaDaemon.getClass().getMethod("setAwait", paramTypes);
        method.invoke(catalinaDaemon, paramValues);
    
    }

    如前文分析,Tomcat 启动时会调用org.apache.catalina.startup.Catalina类的 start 方法,看下这个方法的代码: 

    1	    /**
     2	     * Start a new server instance.
     3	     */
     4	    public void start() {
     5
     6	        if (getServer() == null) {
     7	            load();
     8	        }
     9
    10	        if (getServer() == null) {
    11	            log.fatal("Cannot start server. Server instance is not configured.");
    12	            return;
    13	        }
    14
    15	        long t1 = System.nanoTime();
    16
    17	        // Start the new server
    18	        try {
    19	            getServer().start();
    20	        } catch (LifecycleException e) {
    21	            log.fatal(sm.getString("catalina.serverStartFail"), e);
    22	            try {
    23	                getServer().destroy();
    24	            } catch (LifecycleException e1) {
    25	                log.debug("destroy() failed for failed Server ", e1);
    26	            }
    27	            return;
    28	        }
    29
    30	        long t2 = System.nanoTime();
    31	        if(log.isInfoEnabled()) {
    32	            log.info("Server startup in " + ((t2 - t1) / 1000000) + " ms");
    33	        }
    34
    35	        // Register shutdown hook
    36	        if (useShutdownHook) {
    37	            if (shutdownHook == null) {
    38	                shutdownHook = new CatalinaShutdownHook();
    39	            }
    40	            Runtime.getRuntime().addShutdownHook(shutdownHook);
    41
    42	            // If JULI is being used, disable JULI's shutdown hook since
    43	            // shutdown hooks run in parallel and log messages may be lost
    44	            // if JULI's hook completes before the CatalinaShutdownHook()
    45	            LogManager logManager = LogManager.getLogManager();
    46	            if (logManager instanceof ClassLoaderLogManager) {
    47	                ((ClassLoaderLogManager) logManager).setUseShutdownHook(
    48	                        false);
    49	            }
    50	        }
    51
    52	        if (await) {
    53	            await();
    54	            stop();
    55	        }
    56	    }

    前文分析启动时发现通过第 19 行 getServer().start() 的这次方法调用,Tomcat 接下来会一步步启动所有在配置文件中配置的组件。后面的代码没有分析,这里请关注最后第 52 到 55 行,上面说到已经将 Catalina 类的实例变量 await 设值为 true,所以这里将会执行 Catalina 类的 await 方法: 

    /**
     * Await and shutdown.
     */
    public void await() {
    
        getServer().await();
    
    }

    该方法就一句话,意思是调用org.apache.catalina.core.StandardServer类的 await 方法: 

    1	    /**
      2	     * Wait until a proper shutdown command is received, then return.
      3	     * This keeps the main thread alive - the thread pool listening for http
      4	     * connections is daemon threads.
      5	     */
      6	    @Override
      7	    public void await() {
      8	        // Negative values - don't wait on port - tomcat is embedded or we just don't like ports
      9	        if( port == -2 ) {
     10	            // undocumented yet - for embedding apps that are around, alive.
     11	            return;
     12	        }
     13	        if( port==-1 ) {
     14	            try {
     15	                awaitThread = Thread.currentThread();
     16	                while(!stopAwait) {
     17	                    try {
     18	                        Thread.sleep( 10000 );
     19	                    } catch( InterruptedException ex ) {
     20	                        // continue and check the flag
     21	                    }
     22	                }
     23	            } finally {
     24	                awaitThread = null;
     25	            }
     26	            return;
     27	        }
     28
     29	        // Set up a server socket to wait on
     30	        try {
     31	            awaitSocket = new ServerSocket(port, 1,
     32	                    InetAddress.getByName(address));
     33	        } catch (IOException e) {
     34	            log.error("StandardServer.await: create[" + address
     35	                               + ":" + port
     36	                               + "]: ", e);
     37	            return;
     38	        }
     39
     40	        try {
     41	            awaitThread = Thread.currentThread();
     42
     43	            // Loop waiting for a connection and a valid command
     44	            while (!stopAwait) {
     45	                ServerSocket serverSocket = awaitSocket;
     46	                if (serverSocket == null) {
     47	                    break;
     48	                }
     49
     50	                // Wait for the next connection
     51	                Socket socket = null;
     52	                StringBuilder command = new StringBuilder();
     53	                try {
     54	                    InputStream stream;
     55	                    try {
     56	                        socket = serverSocket.accept();
     57	                        socket.setSoTimeout(10 * 1000);  // Ten seconds
     58	                        stream = socket.getInputStream();
     59	                    } catch (AccessControlException ace) {
     60	                        log.warn("StandardServer.accept security exception: "
     61	                                + ace.getMessage(), ace);
     62	                        continue;
     63	                    } catch (IOException e) {
     64	                        if (stopAwait) {
     65	                            // Wait was aborted with socket.close()
     66	                            break;
     67	                        }
     68	                        log.error("StandardServer.await: accept: ", e);
     69	                        break;
     70	                    }
     71
     72	                    // Read a set of characters from the socket
     73	                    int expected = 1024; // Cut off to avoid DoS attack
     74	                    while (expected < shutdown.length()) {
     75	                        if (random == null)
     76	                            random = new Random();
     77	                        expected += (random.nextInt() % 1024);
     78	                    }
     79	                    while (expected > 0) {
     80	                        int ch = -1;
     81	                        try {
     82	                            ch = stream.read();
     83	                        } catch (IOException e) {
     84	                            log.warn("StandardServer.await: read: ", e);
     85	                            ch = -1;
     86	                        }
     87	                        if (ch < 32)  // Control character or EOF terminates loop
     88	                            break;
     89	                        command.append((char) ch);
     90	                        expected--;
     91	                    }
     92	                } finally {
     93	                    // Close the socket now that we are done with it
     94	                    try {
     95	                        if (socket != null) {
     96	                            socket.close();
     97	                        }
     98	                    } catch (IOException e) {
     99	                        // Ignore
    100	                    }
    101	                }
    102
    103	                // Match against our command string
    104	                boolean match = command.toString().equals(shutdown);
    105	                if (match) {
    106	                    log.info(sm.getString("standardServer.shutdownViaPort"));
    107	                    break;
    108	                } else
    109	                    log.warn("StandardServer.await: Invalid command '"
    110	                            + command.toString() + "' received");
    111	            }
    112	        } finally {
    113	            ServerSocket serverSocket = awaitSocket;
    114	            awaitThread = null;
    115	            awaitSocket = null;
    116
    117	            // Close the server socket and return
    118	            if (serverSocket != null) {
    119	                try {
    120	                    serverSocket.close();
    121	                } catch (IOException e) {
    122	                    // Ignore
    123	                }
    124	            }
    125	        }
    126	    }

    这段代码就不一一分析,总体作用如方法前的注释所说,即“一直等待到接收到一个正确的关闭命令后该方法将会返回。这样会使主线程一直存活——监听http连接的线程池是守护线程”。

    熟悉 Java 的 Socket 编程的话对这段代码就很容易理解,就是默认地址(地址值由实例变量 address 定义,默认为localhost)的默认的端口(端口值由实例变量 port 定义,默认为8005)上监听 Socket 连接,当发现监听到的连接的输入流中的内容与默认配置的值匹配(该值默认为字符串SHUTDOWN)则跳出循环,该方法返回(第 103 到 107 行)。否则该方法会一直循环执行下去。 一般来说该用户主线程会阻塞(第 56 行)直到有访问localhost:8005的连接出现。 正因为如此才出现开头看见的主线程一直 Running 的情况,而因为这个线程一直 Running ,其它守护线程也会一直存在。

    说完这个线程的产生,接下来看看这个线程的关闭,按照上面的分析,这个线程提供了一个关闭机制,即只要访问localhost:8005,并且发送一个内容为SHUTDOWN的字符串,就可以关闭它了。

    Tomcat 正是这么做的,一般来说关闭 Tomcat 通过执行 shutdown.bat 或 shutdown.sh 脚本,关于这段脚本可参照分析启动脚本那篇文章,机制类似,最终会执行org.apache.catalina.startup.Bootstrap类的 main 方法,并传入入参"stop",看下本文第 2 张图片中org.apache.catalina.startup.Bootstrap类的第 458 行,接着将调用org.apache.catalina.startup.Catalina类 stopServer 方法:

     1	    public void stopServer(String[] arguments) {
     2
     3	        if (arguments != null) {
     4	            arguments(arguments);
     5	        }
     6
     7	        Server s = getServer();
     8	        if( s == null ) {
     9	            // Create and execute our Digester
    10	            Digester digester = createStopDigester();
    11	            digester.setClassLoader(Thread.currentThread().getContextClassLoader());
    12	            File file = configFile();
    13	            FileInputStream fis = null;
    14	            try {
    15	                InputSource is =
    16	                    new InputSource(file.toURI().toURL().toString());
    17	                fis = new FileInputStream(file);
    18	                is.setByteStream(fis);
    19	                digester.push(this);
    20	                digester.parse(is);
    21	            } catch (Exception e) {
    22	                log.error("Catalina.stop: ", e);
    23	                System.exit(1);
    24	            } finally {
    25	                if (fis != null) {
    26	                    try {
    27	                        fis.close();
    28	                    } catch (IOException e) {
    29	                        // Ignore
    30	                    }
    31	                }
    32	            }
    33	        } else {
    34	            // Server object already present. Must be running as a service
    35	            try {
    36	                s.stop();
    37	            } catch (LifecycleException e) {
    38	                log.error("Catalina.stop: ", e);
    39	            }
    40	            return;
    41	        }
    42
    43	        // Stop the existing server
    44	        s = getServer();
    45	        if (s.getPort()>0) {
    46	            Socket socket = null;
    47	            OutputStream stream = null;
    48	            try {
    49	                socket = new Socket(s.getAddress(), s.getPort());
    50	                stream = socket.getOutputStream();
    51	                String shutdown = s.getShutdown();
    52	                for (int i = 0; i < shutdown.length(); i++) {
    53	                    stream.write(shutdown.charAt(i));
    54	                }
    55	                stream.flush();
    56	            } catch (ConnectException ce) {
    57	                log.error(sm.getString("catalina.stopServer.connectException",
    58	                                       s.getAddress(),
    59	                                       String.valueOf(s.getPort())));
    60	                log.error("Catalina.stop: ", ce);
    61	                System.exit(1);
    62	            } catch (IOException e) {
    63	                log.error("Catalina.stop: ", e);
    64	                System.exit(1);
    65	            } finally {
    66	                if (stream != null) {
    67	                    try {
    68	                        stream.close();
    69	                    } catch (IOException e) {
    70	                        // Ignore
    71	                    }
    72	                }
    73	                if (socket != null) {
    74	                    try {
    75	                        socket.close();
    76	                    } catch (IOException e) {
    77	                        // Ignore
    78	                    }
    79	                }
    80	            }
    81	        } else {
    82	            log.error(sm.getString("catalina.stopServer"));
    83	            System.exit(1);
    84	        }
    85	    }

    第 8 到 41 行是读取配置文件,可参照前面分析 Digester 的文章,不再赘述。从第 49 行开始,即向localhost:8005发起一个 Socket 连接,并写入SHUTDOWN字符串。 这样将会关闭 Tomcat 中的那唯一的一个用户线程,接着所有守护线程将会退出(由 JVM 保证),之后整个应用关闭。

    以上分析 Tomcat 的默认关闭机制,但这是通过运行脚本来关闭,我觉得这样比较麻烦,那么能不能通过一种在线访问的方式关闭 Tomcat 呢?当然可以,比较暴力的玩法是直接改org.apache.catalina.core.StandardServer的源码第 500 行,将

    boolean match = command.toString().equals(shutdown);
    

    改成 

    boolean match = command.toString().equals(“GET /SHUTDOWN HTTP/1.1”);
    

    或者修改 server.xml 文件,找到 Server 节点,将原来的 

    <Server port="8005" shutdown="SHUTDOWN">
    

    改成 

    <Server port="8005" shutdown="GET /SHUTDOWN HTTP/1.1">
    

    这样直接在浏览器中输入http://localhost:8005/SHUTDOWN就可以关闭 Tomcat 了,原理?看懂了上面的文章,这个应该不难。 

    展开全文
  • 有两个解决办法,第一个修改成别的端口启动tomcat,第二个找到占用端口的后台进程,杀死这个进程,自然就解决了端口占用。 第二个配置默认主页,默认应用。端设置默认主页和默认应用,就是输入一个地址,我不...

    本篇来学习Tomcat常见两个配置知识,

    • 第一个是端口占用的场景以及如何解决端口占用。
      有两个解决办法,第一个是修改成别的端口启动tomcat,第二个是找到占用端口的后台进程,杀死这个进程,自然就解决了端口占用。
    • 第二个是配置默认主页,默认应用。端设置默认主页和默认应用,就是输入一个地址,我不输入URI后面的什么html文件,也能够自动打开这个html文件。

    1.端口占用问题

    为了重现端口占用问题,我在cmd窗口再次启动tomcat,看看发生什么。在启动过程发现出错了,一闪而过,窗口就关闭了, 只好去tomcat目录下看日志文件了。打开catalina.2019-05-05.log日志文件,找到JVM_Bind位置。

    05-May-2019 16:30:49.902 严重 [main] org.apache.catalina.core.StandardServer.await StandardServer.await: create[localhost:8005]: 
     java.net.BindException: Address already in use: JVM_Bind
    	at java.net.DualStackPlainSocketImpl.bind0(Native Method)
    	at java.net.DualStackPlainSocketImpl.socketBind(DualStackPlainSocketImpl.java:106)
    	at java.net.AbstractPlainSocketImpl.bind(AbstractPlainSocketImpl.java:387)
    	at java.net.PlainSocketImpl.bind(PlainSocketImpl.java:190)
    	at java.net.ServerSocket.bind(ServerSocket.java:375)
    	at java.net.ServerSocket.<init>(ServerSocket.java:237)
    	at org.apache.catalina.core.StandardServer.await(StandardServer.java:440)
    	at org.apache.catalina.startup.Catalina.await(Catalina.java:776)
    	at org.apache.catalina.startup.Catalina.start(Catalina.java:722)
    	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    	at java.lang.reflect.Method.invoke(Method.java:498)
    	at org.apache.catalina.startup.Bootstrap.start(Bootstrap.java:353)
    	at org.apache.catalina.startup.Bootstrap.main(Bootstrap.java:493)
    
    
    

    jVM_Bind就是Java虚拟机已经绑定的意思。以后看到这个错误,就要想起端口被占用。端口默认是8080.也就是这个8080端口被占用,解决这个问题有两个办法

    1. 修改tomcat下conf下server.xml中的端口改成8080之外的,这种方法还不一定好用。
    2. 找出占用端口的程序,后台把进程杀掉就好了。

    这里详细介绍下第二个方法。

    在cmd里输入命令: netstat -ano, 这里我截取一部分,主要看8080这个对应进程ID。

    C:\Users\wwj>netstat -ano
     
    活动连接
     
      协议  本地地址          外部地址        状态           PID
      TCP    0.0.0.0:135            0.0.0.0:0              LISTENING       1164
      TCP    0.0.0.0:445            0.0.0.0:0              LISTENING       4
      TCP    0.0.0.0:2179           0.0.0.0:0              LISTENING       4960
      TCP    0.0.0.0:3389           0.0.0.0:0              LISTENING       1508
      TCP    0.0.0.0:5040           0.0.0.0:0              LISTENING       15044
      TCP    0.0.0.0:7680           0.0.0.0:0              LISTENING       7816
      TCP    0.0.0.0:8009           0.0.0.0:0              LISTENING       7968
      TCP    0.0.0.0:8080           0.0.0.0:0              LISTENING       7968
      TCP    0.0.0.0:8180           0.0.0.0:0              LISTENING       4512
      TCP    0.0.0.0:49664          0.0.0.0:0              LISTENING       968
    
    
    

    在上面,找到8080占用进程的PID是7968, 然后我们去任务管理器中找到这个PID,右键选择关闭进程。

    2.设置默认主页和默认应用

    默认端口

    这里说的默认端口是指80,之前我们是这样输入网址去访问的http://localhost:8080/MyApp01/123.html

    如果通过配置,这样也能访问http://localhost/MyApp01/123.html

    这个就是这里说的默认端口配置,很简单浏览器访问默认端口是80,所以,我们需要去conf/server.xml文件把tomcat端口8080改成80,前提你系统80端口没有被占用。

        <Connector port="80" protocol="HTTP/1.1"
                   connectionTimeout="20000"
                   redirectPort="8443" />
    

    然后不加端口号也可以直接进行访问;

    默认主页

    什么是默认主页呢,之前我们是http://localhost/MyApp01/123.html 才能访问,

    如果通过这样http://localhost/MyApp01/也能访问123.html的效果,这个就是默认主页。一般在登陆场景中我们应该经常见到;

    我们这样去设置,在Tomcat中的conf下找到web.xml文件,编辑打开

    在web.xml文件最后几行内容,或者搜索 welcome找到

        <welcome-file-list>
            <welcome-file>123.html</welcome-file>
            <welcome-file>index.htm</welcome-file>
            <welcome-file>index.jsp</welcome-file>
        </welcome-file-list>
    

    welcome-file是这样的,这里默认设置了3个,如果找不到123.html就找第二个index.htm,如果第二个找不到,就找第三个,所以,这里可以设置3个默认的主页。

    默认应用

    这里来说,默认应用,我们的应用名称是MyApp01, 如果tomcat访问不输入这个名称,默认访问的是tomcat的默认项目。
    在这里插入图片描述

    这个页面就是访问默认应用,就是下面这个ROOT项目。
    在这里插入图片描述
    所以,我们想把这个效果改成默认使用我们自己应用MyApp01,我们可以在Tomcat的webapps目录把MyApp01重名为ROOT,重启Tomcat服务就可以。

    展开全文
  • 命令结束进程

    2020-02-19 17:24:18
    查看8080这个进程是否在跑 netstat -aon|findstr 8080 查看pdi为1900是什么进程再跑 tasklist|findstr "1900 强制结束tomcat7这个进程 taskkill /im tomcat7.exe /f

    查看8080这个进程是否在跑
    netstat -aon|findstr 8080

    查看pdi为1900是什么进程再跑
    tasklist|findstr "1900

    强制结束tomcat7这个进程
    taskkill /im tomcat7.exe /f

    展开全文
  • java io学习---tomcat

    2017-12-19 16:07:33
    简介什么是tomcat操作系统对于进程中的线程数有一定的限制:  Windows 每个进程中的线程数不允许超过 2000;  Linux 每个进程中的线程数不允许超过 1000;  另外,在 Java 中每开启一个线程需要耗用 1MB 的 ...
  • !... !... ...我把tomcat默认端口,修改成了8088端口,防止其他进程占用8080端口!...tomcat可以正常启动!... 运行环境:win10 tomcat 7.093...这到底是什么问题。百度了好久试了好多方法还是不行!求大佬帮忙看看到底那里问题!
  • Nginx+Tomcat负载均衡

    2015-01-13 09:07:18
    在Win7上做的。不是什么Linux,网上好多资料,特别麻烦。 Nginx Nginx 比较好找到,直接去网上下载 网址: http://nginx.org/en/download.html 版本不作要求了,(比如1.2.9版本),都有。 JDK JAVA的各种环境都...
  • 问题详情(先看这部分如果你的问题和我一样可以继续...然后用./shutdown.sh 命令却提示Connection refused,但是用命令ps -ef|grep tomcat7(根据你的版本) 却发现已经有进程启动了 这什么呢?这个问题也纠结了我...
  • 环境:Centos 7 Jenkins版本:2.124 ...但是,Tomcat只是启动了一下,就关闭了,并没有启动Tomcat进程。 在网上查了资料,需要在执行脚本之前加入:export BUILD_ID=XXXXXX XXXXX可以随便写的什么 ...
  • 在master管理进程与worker工作进程的分离设计,使的Nginx具有热部署的功能,那么在7×24小时不间断服务的前提下,升级Nginx的可执行文件。也可以在不停止服务的情况下修改配置文件,更换日志文件等功能。 2、可以高...
  • 最近在进行一个小型的web工程开发,这个web做运维局域网内服务器的平台,项目的基本功能现在已经实现的差不多了,但是在发布部署在tomcat上碰到了一些...tomcat7服务器,端口已经把默认的8080改成没占用过的其他端口
  • 操作系统centos7,安装了tomcat,根目录满了,du -h --max-depth=1,没有大文件。 ![图片说明](https://img-ask.csdn.net/upload/201812/21/1545371999_484230.png) lsof |grep delete也没有大文件删除后继续...
  • 1.tomcat的端口被占用了怎么办? 解决方法:1) 这里就以win7为例进行讲解。 首先在开始菜单中直接输入cmd回车即可。同样也可以按下win+R打开运行,然后输入cmd即可。 在dos命令中输入命令:netstat -ano...
  • 一、前言 GitBlit一个开源的Git服务器,这篇博文记录GitBlitit安装过程。一开始用的tar.gz包安装,有2种启动方式,命令启动后服务可以访问,但关闭Xshell...部署环境:Centos7,JDK1.8,Tomcat8.5。(jdk,To...
  • 服务器我配置的,项目框架spring+mybaits ,数据库mysql5.5,服务器tomcat7下附两张数据库show processlist命令,里面的sleep和time完全不同,一个正常,一个不断增长![图片]...
  • java开源包7

    热门讨论 2013-06-28 09:52:16
    7、支持自定义通信协议,可完全替换NFS-RPC自带的协议。 淘宝开放平台JAVA版SDK top4java 设计原则 容易维护扩展(不需要修改主类就可以添加新的API支持) 注入型解释器(依据不同的返回格式注入相应的解释器) ...
  • 3.服务端端口号710,如何查看进程号?4.查看cpu和内存情况5.vim文件编辑的操作流程和查询方法?6.Linux下需要设置环境变量,具体有哪些地方会用到定义变量?7.Linux中用过哪些中间件?9.TomCAT的日志存放在哪里?...
  • zabbix全网监控介绍

    2019-04-08 10:29:00
    应用层:监控协议http/https/ssh 如nginx mysql rsync tomcat(进程,URL地址、服务是否正常使用) 表示层:表示层 会话层:会话层 传输层:监控TCP/UDP端口 网络层:IP地址,一般监控带宽的延迟 数据链路层:MAC...
  • 2.在工作过程中最有技术深度对自己援高...7.如果你设计的存储超过了物理机的实际存储、有什么后果吗? 当应用程序需要的内存超出堆的最大值时服务器就会提示内存溢出,并且导致应用服务崩溃 9.一个进程启动后 可以操作
  • web面试题收集

    千次阅读 多人点赞 2021-03-08 22:13:21
    怎么配置2、nginx前端页面/图片加载不出来,如何排查3、nginx+keepalived脑裂是什么、怎么预防、怎么处理4、nginx和lvs、haproxy有什么区别5、Tomcat优化 Web 1、nginx优化哪些、有没有做过nginx支持https的访问,...
  • 7、创建线程有几种方式,分别是什么? 58 8、线程的生命周期 59 9、线程currentThread()与interrupt()方法的使用 59 10、线程状态 59 启动线程的方式?start or run? 59 11、什么是java序列化,如何实现java序列化?...
  • 高并发的解决方案

    2018-09-11 17:49:00
    什么是高并发:多个进程或者线程同时(或者在同一段时间内)访问统一资源会产生的并发问题 一.高并发初期解决方案: 1.0系统或服务器级别解决方案: 1.增大服务器的CPU 2.增加内存条 3.增加硬盘个数,对硬盘做Radis...
  • 4.1.5 用过哪些Map类,都有什么区别,HashMap是线程安全的吗,并发下使用的Map是什么,他们内部原理分别是什么,比如存储方式,hashcode,扩容,默认容量等。 4.1.6 JAVA8的ConcurrentHashMap为什么放弃了分段锁,有...
  • java基础题 很全面

    2009-05-09 09:24:24
    46. 在linux下 怎么查看tomcat进程? 12 47. 简述逻辑操作(&,|,^)与条件操作(&&,||)的区别。 12 48. XML文档定义有几种形式?它们之间有何本质区别?解析XML文档有哪几种方式? 12 49. 你在项目中用到了xml技术的哪些...
  • java面试题典 java 面试题 经典

    热门讨论 2010-06-18 13:42:36
    5. JSP和Servlet有哪些相同点和不同点,他们之间的联系是什么? 28 6. 四种会话跟踪技术 28 7. Request对象的主要方法: 28 8. jsp有哪些动作?作用分别是什么 29 9. 两种跳转方式分别是什么?有什么区别? 29 10. JAVA...
  • 1.3.1 什么是虚拟机软件 9 1.3.2 使用虚拟机软件的好处 9 1.3.3 虚拟机的运行环境和硬件需求 9 1.3.4 虚拟机的安装与使用 10 1.4 Linux学习资源 20 1.4.1 网络资源、搜索引擎、论坛 20 1.4.2 有本书在身边 20 1.5 ...
  • 27、GC是什么? 为什么要有GC?  GC是垃圾收集的意思(Gabage Collection),内存处理是编程人员容易出现问题的地方,忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃,Java提供的GC功能可以自动监测对象...
  • java开源包1

    千次下载 热门讨论 2013-06-28 09:14:34
    7、支持自定义通信协议,可完全替换NFS-RPC自带的协议。 淘宝开放平台JAVA版SDK top4java 设计原则 容易维护扩展(不需要修改主类就可以添加新的API支持) 注入型解释器(依据不同的返回格式注入相应的解释器) ...
  • java开源包12

    热门讨论 2013-06-28 10:14:45
    7、支持自定义通信协议,可完全替换NFS-RPC自带的协议。 淘宝开放平台JAVA版SDK top4java 设计原则 容易维护扩展(不需要修改主类就可以添加新的API支持) 注入型解释器(依据不同的返回格式注入相应的解释器) ...
  • Java资源包01

    2016-08-31 09:16:25
    7、支持自定义通信协议,可完全替换NFS-RPC自带的协议。 淘宝开放平台JAVA版SDK top4java 设计原则 容易维护扩展(不需要修改主类就可以添加新的API支持) 注入型解释器(依据不同的返回格式注入相应的解释器) ...

空空如也

空空如也

1 2 3 4
收藏数 61
精华内容 24
关键字:

tomcat7是什么进程