使用场景
项目测试时发现并发数量增加到一定程度就会很卡,于是我想到了是不是tomcat最大连接数设置有限制.果不其然,配置文件中最大值才500,于是我更改了最大连接数,根据业务我修改了连接数为1500,完美的解决了这个问题;
修改方法在conf/service.xml中默认值
<Connector port="8080" maxHttpHeaderSize="8192" maxThreads="1500"
   minSpareThreads="30" maxSpareThreads="75" enableLookups="false"
   redirectPort="8443" acceptCount="100" connectionTimeout="20000"
   disableUploadTimeout="true" />

修改maxthreads=1500的值即可

WebSocket现在很常用，想要测试tomcat的最大连接数，今天试了一个可行的办法和配置（之前是用全公司的设备一起来测试的，真机环境的测试收到网络的影响很大，其实真实环境应用中，网络才是websocket的最大瓶颈）
废话不多说~
1.Tomcat需要设置的地方(很多人从网上找的配置试了不可行)：
1.1修改catalina.sh或者catalina.bat文件，加上这句话（JAVA_OPTS="-server -Xms2048m -Xmx2048m -Xmn512m"）。
1.2修改conf下server.xml,    
            <Connector port="8180" protocol="org.apache.coyote.http11.Http11NioProtocol" connectionTimeout="20000" acceptCount="4000" 
                  maxThreads="500" maxConnections="4000" enableLookups="false"  redirectPort="8443" />
上面的设置1.1影响最终你的最大连接数，1.2的maxConnections就是最大连接数，有时候觉得设置无效，请把1.1的内存一起调大！


2.通过Java来测试最大连接数：
package com.jh.order;



import java.NET.URI;



import javax.websocket.ClientEndpoint;

import javax.websocket.ContainerProvider;

import javax.websocket.Session;

import javax.websocket.WebSocketContainer;



@ClientEndpoint

public class WebSocketTest {


private String deviceId;

private Session session;

public WebSocketTest () {
}

public WebSocketTest (String deviceId) {
this.deviceId = deviceId;
}

protected boolean start() {
WebSocketContainer Container = ContainerProvider.getWebSocketContainer();
String uri = "ws://192.168.12.161/orderapp/recommend?role=1&group=recommend&dldm="+ deviceId;
System.out.println("Connecting to " + uri);
try {
session = container.connectToServer(WebSocketTest.class, URI.create(uri));
System.out.println("count: " + deviceId);
} catch (Exception e) {
e.printStackTrace();
return false;
}
return true;
}

public static void main(String[] args) {
for (int i = 1; i< 50000; i++) {
WebSocketTest wSocketTest = new WebSocketTest(String.valueOf(i));
if (!wSocketTest.start()) {
System.out.println("测试结束！");
break;
}
}
}

}

packagecom.chat.demo;/**  Licensed to the Apache Software Foundation (ASF) under one or more
*  contributor license agreements.  See the NOTICE file distributed with
*  this work for additional information regarding copyright ownership.
*  The ASF licenses this file to You under the Apache License, Version 2.0
*  (the "License"); you may not use this file except in compliance with
*  the License.  You may obtain a copy of the License at
*
*http://www.apache.org/licenses/LICENSE-2.0*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.*/
importjava.io.IOException;importjava.util.Set;importjava.util.concurrent.CopyOnWriteArraySet;importjava.util.concurrent.atomic.AtomicInteger;importjavax.websocket.OnClose;importjavax.websocket.OnError;importjavax.websocket.OnMessage;importjavax.websocket.OnOpen;importjavax.websocket.Session;importjavax.websocket.server.ServerEndpoint;//import org.apache.juli.logging.Log;//import org.apache.juli.logging.LogFactory;//import util.HTMLFilter;
@ServerEndpoint(value= "/websocket/chat")public classChatAnnotation {//private static final Log log = LogFactory.getLog(ChatAnnotation.class);
private static final String GUEST_PREFIX = "Guest";private static final AtomicInteger connectionIds = new AtomicInteger(0);private static final Set connections =
new CopyOnWriteArraySet();private finalString nickname;privateSession session;publicChatAnnotation() {
nickname= GUEST_PREFIX +connectionIds.getAndIncrement();
}
@OnOpenpublic voidstart(Session session) {this.session =session;
connections.add(this);
String message= String.format("* %s %s", nickname, "has joined.");
broadcast(message);
}
@OnClosepublic voidend() {
connections.remove(this);
String message= String.format("* %s %s",
nickname,"has disconnected.");
broadcast(message);
}
@OnMessagepublic voidincoming(String message) {//Never trust the client
String filteredMessage = String.format("%s: %s",
nickname, message.toString());
broadcast(filteredMessage);
}
@OnErrorpublic void onError(Throwable t) throwsThrowable {
System.out.println("Chat Error: " +t.toString());
}private static voidbroadcast(String msg) {for(ChatAnnotation client : connections) {try{synchronized(client) {
client.session.getBasicRemote().sendText(msg);
}
}catch(IOException e) {//log.debug("Chat Error: Failed to send message to client", e);
connections.remove(client);try{
client.session.close();
}catch(IOException e1) {//Ignore
}
String message= String.format("* %s %s",
client.nickname,"has been disconnected.");
broadcast(message);
}
}
}
}

首先看看springboot内置的tomcat，该如何配置这两个参数

# 在配置文件中添加如下内容
# tomcat最大线程数，默认为200
server.tomcat.max-threads=200
# tomcat最大连接数，默认为10000（网上的说法）
server.tomcat.max-connections=300

如何理解上面两个参数

为了方便理解，我这里使用了springboot编写了一个简单了的服务，包含一个模拟登录的接口，并使用jmeter进行测试，不了解jmeter如何使用的朋友可以翻看我的历史文章。部分代码如下

// java 代码
@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UsersRepository usersRepository;

    @PostMapping("/login")
    public String login(Users user) throws InterruptedException {
        // 这里将线程挂起3秒，方便观察结果
        Thread.sleep(3000);
        Users checkUser = usersRepository.findByName(user.getName());
        if(checkUser == null)
            return "用户不存在";
        if(!checkUser.getPassword().equals(user.getPassword()))
            return "密码错误";
        System.out.println("用户:" + checkUser.getName() + ",登录成功");
        return "登录成功";
    }
}

接下来，设置jmeter中的线程数，分别测试以下场景返回的结果

注意：我在java代码中添加将线程挂起3秒的语句，实际的响应时间应该减去3秒

 

场景1：并发请求数 <= tomcat最大线程数200



 

结论：可以看到200个请求，平均响应时间为(3156-3000)=156ms,最小响应时间为23ms，最大响应时间为336ms,响应结果正常。

 

场景2：并发数 >tomcat最大线程数200，以下我将jmeter线程数设置为201，再来看看结果



看了下，平均值，最小值好像没什么异常，但是最大值却去到了5606毫秒，接近6S的时间。为什么会有个接近6S的最大值，原因很简单，因为tomcat最大的线程数为200,201的并发请求量，超出了并发处理的数量200，多出来的1个请求，需要等待某个处理中的请求处理完成。

这里我翻看了jmeter中大部分的http请求，验证了我的想法。大部分的http请求，响应时间都是3000多毫秒，只有最后一个响应的请求，响应的时间为5606毫秒，截图如下



 

场景3：请求数超过最大连接数300，这里将jmeter并发线程数设置为600



 可以看到有大量的没有正常响应的http请求，原因很简单，因为超过了tomcat设置的最大连接数，服务器拒绝了该次请求的连接