Redis —— 项目使用：缓存数据（三）

ゝ一世哀愁。 2024-01-22 06:05 62阅读 0赞

#### 之前的博客 https://blog.csdn.net/DGH2430284817/article/details/88677047 中，在测试的时候，都是同步地查询数据库，几千或者更多的查询都是排着队去访问服务器，在这种情况下很明显地可以看到Redis对系统的查询性能的增强，但是现实情况有可能同一时间几百或者上千的访问，这时候Redis的效率还能那么高吗？下面我们用多线程来试试： ####

## 测试类： ##

### 非Redis查询线程类： ###

/**
     * @author 线程类，用于非Redis查询
     *
     */
    class findOneNoRedis implements Runnable{
    	TestClient3 testClient3 = null;
        public findOneNoRedis(TestClient3 testClient3) {
    		super();
    		this.testClient3 = testClient3;
    	}
        @Override
        public  void  run() {
        	//long startTime = testClient3.getTime();
    		String Msg = String.valueOf(1+(int)(Math.random()*testClient3.SearchStuNum));//随机1-XXX
    			 //String Msg = "1";
    			 try {
    				String resString =testClient3.doPostRequest("http://localhost:8080/Maven_SSM/Stu/findOneNoRedis.action", Msg, Charset.forName("UTF-8"), 10, 10);
    			} catch (Exception e) {
    				e.printStackTrace();
    			}
    			 //testClient3.innerNoRedis((testClient3.getTime()-startTime));
    			 testClient3.innerNoRedisNum();
        }
    }

### Redis查询线程类： ###

/**
     * @author 线程类，用于Redis查询
     *
     */
    class findOneByRedis implements Runnable{
    	TestClient3 testClient3 = null;
        public findOneByRedis(TestClient3 testClient3) {
    		super();
    		this.testClient3 = testClient3;
    	}
        @Override
        public  void  run() {
        	//long startTime = testClient3.getTime();
    		String Msg = String.valueOf(1+(int)(Math.random()*testClient3.SearchStuNum));//随机1-XXX
        	//String Msg = "1";
    			 try {
    				String resString =testClient3.doPostRequest("http://localhost:8080/Maven_SSM/Stu/findOneByRedis.action", Msg, Charset.forName("UTF-8"), 10, 10);
    			} catch (Exception e) {
    				e.printStackTrace();
    			}
    			 //testClient3.innerByRedis((testClient3.getTime()-startTime));
    			 testClient3.innerByRedisNum();
        }
    }

### 实现过程： ###

#### 首先多少次查询就开多少个线程，在开启线程前定义一个开启时间，再定义一个查询完成次数，每个线程执行完查询操作后将查询完成次数加一，当查询完成次数等于我们要查询的次数时说明查询完成，打印一共花费时间 ####

## 完整测试类（TestClient3.java）： ##

import java.io.BufferedReader;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.net.HttpURLConnection;
    import java.nio.charset.Charset;
    import java.net.URL;
    import org.springframework.util.Assert;
     
    public class TestClient3 {
     
    	private long NoRedisStartTime = 0;//非redis查询开始时间
    	private long ByRedisStartTime = 0;//redis查询开始时间
    	private long NoRedisNum = 0;//查询完成次数，当次数大于等于查询总次数时输出非redis查询总时间
    	private long ByRedisNum = 0;//查询完成次数，当次数大于等于查询总次数时输出redis查询总时间
    	private long SearchNum = 3000;//查询总次数
    	public int SearchStuNum = 30;//查询学生人数
    	
    	public static void main(String[] args) throws Exception {
    		TestClient3 aaClient = new TestClient3();
    		//String Msg = "client sent to server";
    		String Msg = "1";//查询数据库表Student的ID
    		String resString =aaClient.doPostRequest("http://localhost:8080/Maven_SSM/Stu/findOneByRedis.action", Msg, Charset.forName("UTF-8"), 10, 10);
    
    		//非Redis查询 测试  
    		findOneNoRedis noRedisThread = new findOneNoRedis(aaClient);
    		aaClient.NoRedisStartTime = System.currentTimeMillis();
    		for(int i =0 ; i < aaClient.SearchNum ; i++){
    			new Thread(noRedisThread).start();
    		}
    		
    //		建议测试时只测一种，另一种注释掉，因为普通的SSM处理能力有限，同时几千个线程同时访问，会出现异常，很多客户端请求会无法连接上服务器
    //		我的电脑最大开到3000个线程不报错，再多的话会有很多客户端请求失效，影响测试结果
    		
    		//Redis查询  测试
    		aaClient.ByRedisStartTime = System.currentTimeMillis();
    		findOneByRedis byRedisThread = new findOneByRedis(aaClient);
    		for(int i =0 ; i < aaClient.SearchNum ; i++){
    			new Thread(byRedisThread).start();
    		}
    	}
    	
    	
    	
    	public synchronized  void  innerNoRedisNum() {
    		NoRedisNum ++ ; 
    		if (NoRedisNum >= SearchNum ) {
    			System.out.println("非Redis查询总用时：" + (System.currentTimeMillis() - NoRedisStartTime));
    		}
    	}
    	public synchronized  void  innerByRedisNum() {
    		ByRedisNum ++ ; 
    		if (ByRedisNum >= SearchNum ) {
    			System.out.println("Redis查询总用时：" + (System.currentTimeMillis() - ByRedisStartTime));
    		}
    	}
    	
    	
    
     
     
    	 /**
    	 * @param reqUrl 地址
    	 * @param params 数据(json)
    	 * @param charset 编码
    	 * @param readTimeSec 
    	 * @param connTimeSec
    	 * @return Http请求返回数据字符串
    	 * @throws Exception
    	 */
    	public static String doPostRequest(String reqUrl, String params,
    				Charset charset, int readTimeSec, int connTimeSec)
    				throws Exception {
    			try {
    				Assert.hasText(reqUrl, "请求地址为空");
    				Assert.hasText(params, "请求数据为空");
    			} catch (Exception e) {
    				throw new Exception("发送请求参数为空:"
    						+ e.getMessage(), e);
    			}
    			String request = params ;//发送服务端数据
    			HttpURLConnection httpConnection = null;
    			try {
    				httpConnection = (HttpURLConnection) new URL(reqUrl)
    						.openConnection();
    				httpConnection.setRequestMethod("POST");
    				httpConnection.setDoOutput(true);
    				httpConnection.setDoInput(true);
    				httpConnection.setUseCaches(false);
    				httpConnection.setRequestProperty("Connection", "Keep-Alive");
    				httpConnection.setRequestProperty("Charset", charset.displayName());
    				httpConnection.setRequestProperty("Content-Type",
    						"application/json; charset=" + charset.displayName());
    				httpConnection.setRequestProperty("accept", "application/json");
    				httpConnection.setReadTimeout(readTimeSec * 1000);// 设置http连接的读超时,单位是毫秒
    				httpConnection.setConnectTimeout(connTimeSec * 1000);
    				// 1、连接
    				try {
    					httpConnection.connect();
    				} catch (Exception e) {
    					throw new Exception(
    							"服务器连接是失败");
    				}
    				OutputStream outwritestream = null;
    				// 2、发送数据
    				try {
    					//System.out.println("请求数据:"+request);
    					byte[] writebytes = request.getBytes(charset);
    					outwritestream = httpConnection.getOutputStream();
    					outwritestream.write(writebytes);
    					outwritestream.flush();
    				} catch (Exception e) {
    					throw new Exception(
    							"请求数据发送失败", e);
    				} finally {
    						try {
    							outwritestream.close();
    						} catch (Exception e) {
    						}
    				}
    				return getHttpReturn(httpConnection , charset);
    			} catch (Exception e) {
    				throw new Exception("服务器连接失败："
    						+ e.getMessage(), e);
    			} finally {
    				if (httpConnection != null) {
    					httpConnection.disconnect();
    				}
    			}
    		}
    	 
    		/**
    		 * @param httpConnection  
    		 * @return Http连接返回数据转化成字符串
    		 * @throws Exception
    		 */
    		private static String getHttpReturn(HttpURLConnection httpConnection , Charset charset)
    				throws Exception {
    			int responseCode = -1;
    			try {
    				responseCode = httpConnection.getResponseCode();
    				//System.out.println("responseCode:"+responseCode);
    			} catch (Exception e) {
    				throw new Exception(
    						"接收数据超时", e);
    			}
    			try {
    				Assert.isTrue(responseCode == 200, "服务器响应码【"
    						+ responseCode + "】");
    			} catch (Exception e) {
    				throw new Exception(
    						"接收数据失败：" + e.getMessage(), e);
    			}
    			BufferedReader reader = null;
    			try {
    				reader = new BufferedReader(new InputStreamReader(
    						httpConnection.getInputStream(), charset));
    				String str = "";
    				String temp;
    		           while((temp = reader.readLine())!=null){ 
    		        	   str = str + temp +"\r\n" ;
    		           }
    				return str;
    			} catch (Exception e) {
    				throw new Exception(
    						"接收数据超时：" + e.getMessage(), e);
    			} finally {
    				try {
    					if (null != reader) {
    						reader.close();
    					}
    				} catch (Exception e) {
    				}
    			}
    		}
    }
    
    /**
     * @author 线程类，用于非Redis查询
     *
     */
    class findOneNoRedis implements Runnable{
    	TestClient3 testClient3 = null;
        public findOneNoRedis(TestClient3 testClient3) {
    		super();
    		this.testClient3 = testClient3;
    	}
        @Override
        public  void  run() {
        	//long startTime = testClient3.getTime();
    		String Msg = String.valueOf(1+(int)(Math.random()*testClient3.SearchStuNum));//随机1-1000
    			 //String Msg = "1";
    			 try {
    				String resString =testClient3.doPostRequest("http://localhost:8080/Maven_SSM/Stu/findOneNoRedis.action", Msg, Charset.forName("UTF-8"), 10, 10);
    			} catch (Exception e) {
    				e.printStackTrace();
    			}
    			 //testClient3.innerNoRedis((testClient3.getTime()-startTime));
    			 testClient3.innerNoRedisNum();
        }
    }
    
    /**
     * @author 线程类，用于Redis查询
     *
     */
    class findOneByRedis implements Runnable{
    	TestClient3 testClient3 = null;
        public findOneByRedis(TestClient3 testClient3) {
    		super();
    		this.testClient3 = testClient3;
    	}
        @Override
        public  void  run() {
        	//long startTime = testClient3.getTime();
    		String Msg = String.valueOf(1+(int)(Math.random()*testClient3.SearchStuNum));//随机1-1000
        	//String Msg = "1";
    			 try {
    				String resString =testClient3.doPostRequest("http://localhost:8080/Maven_SSM/Stu/findOneByRedis.action", Msg, Charset.forName("UTF-8"), 10, 10);
    			} catch (Exception e) {
    				e.printStackTrace();
    			}
    			 //testClient3.innerByRedis((testClient3.getTime()-startTime));
    			 testClient3.innerByRedisNum();
        }
    }

## 测试结果： ##

非Redis查询总用时：3862
    Redis查询总用时：3753

**结论：说明在高并发的情况下，Redis的效率会降低，用不用Redis的效果差不多，缓存的优势没有用出来。（当然也有可能是我开启的线程数太少，只开了3000个线程，但是电脑性能和SSM项目的性能不够好，再增加线程数会出现SSM项目无法同时接受那么多的请求，有很多客户端请求会连接不上服务器）**