精华内容
下载资源
问答
  • 高并发模拟多个用户同时访问所写接口,用于测试接口所需要的的并发,和接口的最多承受用户量,适用于一些简单的压力测试。
  • 高并发场景模拟测试

    2019-04-03 19:13:39
    通过CountDownLatch对高并发场景模拟测试,基于AQS同步队列实现,先阻塞,等待所有线程达到并发执行的效果。
  • 高并发模拟实验1-情景模拟

    千次阅读 2019-03-19 14:21:27
    查看高并发情况下数据逻辑上出现的错误问题(注:这里不考虑服务器负载等性能问题) 实验描述 假设存在商品表goods,表包含两个字段:ID,quantity,其中ID为主键,代表商品编号,quantity代表商品库存数量,服务端...

    实验目的
    查看高并发情况下数据逻辑上出现的错误问题(注:这里不考虑服务器负载等性能问题)

    实验描述
    假设存在商品表goods,表包含两个字段:ID,quantity,其中ID为主键,代表商品编号,quantity代表商品库存数量,服务端设计程序模拟购物,每购买一件(客户端每请求一次),商品库存就减一。在测试会话中使用ab压力测试工具模拟以下两种情况,分别查看库存剩余量。假设库存总量为100,请求完毕,正确的库存剩余量应该是80。

    (1)有20个人依次排队进行购物,每人购买一件。

    (2)同时有10个人进行购物操作,总的购买量为20(即总的请求个数为20,每次发送10个请求)

    实验环境:fedora29

    所需软件:apache,php,mysql,ab

    实验步骤

    建立初始数据

    MariaDB [test]> CREATE DATABASE `test`;
    MariaDB [test]> CREATE TABLE `goods` (
        -> `ID` int(10) DEFAULT NULL,
        -> `quantity` int(10) DEFAULT NULL
        -> ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    Query OK, 0 rows affected (0.693 sec)
    MariaDB [test]> insert into goods values(1,100);
    Query OK, 1 row affected (0.068 sec)
    MariaDB [test]> select * from goods;
    +------+----------+
    | ID   | quantity |
    +------+----------+
    |    1 |      100 |
    +------+----------+
    1 row in set (0.000 sec)
    

    购物处理程序buy.php

    <?php
    $db = new MySQLi("localhost","root","yptest","test");
    $query = "select quantity from a where ID =1";
    $res =$db->query($query);
    while($row=mysqli_fetch_array($res)){
       $quantity = $row['quantity'];
    }
    $sql = "update goods set quantity = $quantity+1 where ID =1";
    $reslut =$db->query($sql);
    //记录操作语句,查看执行细节
    $file = fopen("log.txt", "a+") or die("Unable to open file!");
    fwrite($file, $sql."\r\n");
    fclose($file);
    if($reslut){
        echo "success";
    }else{
        echo "error";
    }
    ?>
    

    模拟请求

    (1)有20个人依次排队进行购物,每人购买一件。

    ab -c 1 -n 20 "http://localhost:9101/buy.php"
    

    结果(正确):

    MariaDB [test]> select * from goods;
    +------+----------+
    | ID   | quantity |
    +------+----------+
    |    1 |       80 |
    +------+----------+
    1 row in set (0.000 sec)
    

    日志(log.txt)明细:

    update goods set quantity = 100-1 where ID =1
    update goods set quantity = 99-1 where ID =1
    update goods set quantity = 98-1 where ID =1
    update goods set quantity = 97-1 where ID =1
    update goods set quantity = 96-1 where ID =1
    update goods set quantity = 95-1 where ID =1
    update goods set quantity = 94-1 where ID =1
    update goods set quantity = 93-1 where ID =1
    update goods set quantity = 92-1 where ID =1
    update goods set quantity = 91-1 where ID =1
    update goods set quantity = 90-1 where ID =1
    update goods set quantity = 89-1 where ID =1
    update goods set quantity = 88-1 where ID =1
    update goods set quantity = 87-1 where ID =1
    update goods set quantity = 86-1 where ID =1
    update goods set quantity = 85-1 where ID =1
    update goods set quantity = 84-1 where ID =1
    update goods set quantity = 83-1 where ID =1
    update goods set quantity = 82-1 where ID =1
    update goods set quantity = 81-1 where ID =1
    

    (2)同时有10个人进行购物操作,总的购买量为20(即总的请求个数为20,每次发送10个请求)

    ab -c 10 -n 20 "http://localhost:9101/concurrency.php"
    

    结果(错误):

    MariaDB [test]> select * from goods;
    +------+----------+
    | ID   | quantity |
    +------+----------+
    |    1 |       87 |
    +------+----------+
    1 row in set (0.000 sec)
    

    日志(log.txt)明细:

    update goods set quantity = 100-1 where ID =1
    update goods set quantity = 99-1 where ID =1
    update goods set quantity = 98-1 where ID =1
    update goods set quantity = 98-1 where ID =1
    update goods set quantity = 99-1 where ID =1
    update goods set quantity = 99-1 where ID =1
    update goods set quantity = 98-1 where ID =1
    update goods set quantity = 97-1 where ID =1
    update goods set quantity = 97-1 where ID =1
    update goods set quantity = 96-1 where ID =1
    update goods set quantity = 95-1 where ID =1
    update goods set quantity = 94-1 where ID =1
    update goods set quantity = 91-1 where ID =1
    update goods set quantity = 93-1 where ID =1
    update goods set quantity = 91-1 where ID =1
    update goods set quantity = 92-1 where ID =1
    update goods set quantity = 91-1 where ID =1
    update goods set quantity = 90-1 where ID =1
    update goods set quantity = 88-1 where ID =1
    update goods set quantity = 89-1 where ID =1
    

    结果分析:

    从结果可以看出,当有10个人同时进行请求购物时,库存剩余量出错,分析日志文件可以看出,在并发请求的情况下,由于无法准确的获取当前库存剩余量,导致在更新库存剩余量出错。

    问题:
    如何保障在10个人同时进行请求购物时,每次请求都能获取到准确的库存剩余量,进而进行库存的更新操作?

    解决办法
    《 高并发模拟实验2-解决高并发问题》

    展开全文
  • //模拟10000个异步请求,进行并发 //真正对数据库存储产生影响的是为user用户的stock数量 var max = 15000; for (var i = 1; i ; i++) { //jQuery的post请求,请注意这是异步请求 $.post({ //根据自己...
  • 基于ssm+mysql+Redis实现高并发模拟,jsp页面用js代码循环访问后台模拟高并发情况,但实际问卷信息存储的数据库的量基础user表中stock数据
  • 主要介绍了你会用Java代码模拟高并发吗,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 在project-1中新建controller,TestController.java内容...50% 15 66% 19 75% 23 80% 24 90% 33 95% 62 98% 84 99% 99 100% 292 (longest request) -n 1000表示本次测试的总数为100个 -c 50表示本次请求的并发数是50

    在project-1中新建controller,TestController.java内容如下:

    @RestController

    @Slf4j

    public class TestController {

    @GetMapping("/test")

    public String test() {

    return "test";

    }

    }

    需要依赖Slf4j包,需要在pom.xml文件中添加依赖:

    org.projectlombok

    lombok

    1.18.6

    POSTMAN工具测试

    在postman工具中新建collection:

    01ea9ca6f5fd20a0511ac411cd8c31b4.png

    并将测试url添加到这个collection中,点击run,然后配置:

    98734588d692413f2d239a6b46d0b0a5.png

    Apache bench工具

    ab -n 1000 -c 50 http://localhost:8080/test

    输出结果如下:

    C:\Users\vincent>ab -n 1000 -c 50 http://localhost:8080/test

    This is ApacheBench, Version 2.3

    Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/

    Licensed to The Apache Software Foundation, http://www.apache.org/

    Benchmarking localhost (be patient)

    Completed 100 requests

    Completed 200 requests

    Completed 300 requests

    Completed 400 requests

    Completed 500 requests

    Completed 600 requests

    Completed 700 requests

    Completed 800 requests

    Completed 900 requests

    Completed 1000 requests

    Finished 1000 requests

    Server Software:

    Server Hostname: localhost

    Server Port: 8080

    Document Path: /test

    Document Length: 4 bytes

    Concurrency Level: 50

    Time taken for tests: 0.673 seconds

    Complete requests: 1000

    Failed requests: 0

    Total transferred: 136000 bytes

    HTML transferred: 4000 bytes

    Requests per second: 1486.74 [#/sec] (mean)

    Time per request: 33.631 [ms] (mean)

    Time per request: 0.673 [ms] (mean, across all concurrent requests)

    Transfer rate: 197.46 [Kbytes/sec] received

    Connection Times (ms)

    min mean[+/-sd] median max

    Connect: 0 0 0.3 0 1

    Processing: 1 19 19.8 15 291

    Waiting: 0 16 16.7 12 278

    Total: 1 20 19.8 15 292

    Percentage of the requests served within a certain time (ms)

    50% 15

    66% 19

    75% 23

    80% 24

    90% 33

    95% 62

    98% 84

    99% 99

    100% 292 (longest request)

    -n 1000表示本次测试的总数为100个

    -c 50表示本次请求的并发数是50

    展开全文
  • 模拟高并发

    千次阅读 2019-01-09 17:30:42
    这几天想鼓捣一下高并发,之前对并发数据一致性处理,使用的synchronized关键字,想试试lock,只不过效果不理想啊, 阶段一:用的lock.lock()和unLock()方法配合,只是保证了数据一致性,只不过会导致有的线程取不...

    这几天想鼓捣一下高并发,之前对并发数据一致性处理,使用的synchronized关键字,想试试lock,只不过效果不理想啊,

    阶段一:用的lock.lock()和unLock()方法配合,只是保证了数据一致性,只不过会导致有的线程取不到结果

    阶段二:使用lock.tryLock()和unLock()方法配合,当试图加锁失败的时候,再次调用业务方法,数据一致性和线程执行成功都得到了保证,但是执行时间有点长,和synchronized没法比啊(继续学习吧。。。)

     

    使用synchronized关键字

    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.Callable;
    import java.util.concurrent.CountDownLatch;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.FutureTask;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReadWriteLock;
    import java.util.concurrent.locks.ReentrantLock;
    import java.util.concurrent.locks.ReentrantReadWriteLock;
    
    /**
     * 高并发模拟
     * */
    public class HighConcurrenceBuy {
    	private ReadWriteLock mReadWriteLock = new ReentrantReadWriteLock();
    //	private Lock lock = mReadWriteLock.readLock();
    	private Lock lock = new ReentrantLock();
    	private People people;
    	private Train train;
    
    	public Train getTrain() {
    		return train;
    	}
    
    	public void setTrain(Train train) {
    		this.train = train;
    	}
    	
    	public void buyTicket(People people) {//卖票
    		synchronized (train) {
    			int ticket = train.getTicket();
    			people.setTicketNumber(ticket);
    			ticket--;
    			train.setTicket(ticket);
    		}
    
    //		if (lock.tryLock()) {
    //			try {
    //				int ticket = train.getTicket();
    //				people.setTicketNumber(ticket);
    //				ticket--;
    //				train.setTicket(ticket);
    //			} catch (Exception e) {
    //				// TODO Auto-generated catch block
    //				e.printStackTrace();
    //			} finally {
    //				lock.unlock();
    //			}
    //		}else {
    //			try {
    //				Thread.currentThread().sleep(100);
    //				buyTicket(people);
    //			} catch (InterruptedException e) {
    //				// TODO Auto-generated catch block
    //				e.printStackTrace();
    //			}
    //		}
    	}
    	
    	public void refundable(People people) {//退票
    		int ticket = train.getTicket();
    		ticket++;
    		train.setTicket(ticket);
    	}
    
    	public People getPeople() {
    		return people;
    	}
    
    	public void setPeople(People people) {
    		this.people = people;
    	}
    	
    	private static int threadSize = 10000;
    	private static CountDownLatch countDown = new CountDownLatch(threadSize);
    	public static void main(String [] args) {
    
    		Train train = new Train("东风",100000);
    		HighConcurrenceBuy buy = new HighConcurrenceBuy();
    		buy.setTrain(train);
    		
    		long startTime = System.currentTimeMillis();
    		System.out.println("主线程start use:" + startTime);
    
    		
    		ExecutorService executor = Executors.newFixedThreadPool(2000);
    		for(int i = 0;i<threadSize;i++) {
    			
    			People people = new People("王"+i);
    			
    			Callable<String> call1 = new Callable<String>() {
    			    @Override  
    			    public String call() throws Exception {  
    			        Thread.sleep(100);
    			        countDown.countDown(); 
    					buy.buyTicket(people);
    
    					System.out.println(Thread.currentThread().getName()+" user time "+(System.currentTimeMillis()-startTime));
    			        //return the thread name executing this callable task  
    			        return Thread.currentThread().getName();  
    			    } 
    				
    			};
    			FutureTask<String> future1 = new FutureTask<String>(call1);
    			executor.execute(future1);
    			
    		}
    		
    		try {
    			countDown.await();
    			System.out.println("end use:" + (System.currentTimeMillis()-startTime));
    		} catch (InterruptedException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		
    	}
    }

    执行结果:

    ...
    pool-1-thread-649 user time 1025
    王9989买到了票编号:90001
    东风号列车还剩:90000张票
    pool-1-thread-1904 user time 1025

     

    使用lock

    执行结果:

    ...
    东风号列车还剩:90001张票
    pool-1-thread-691 user time 3361
    东风号列车还剩:90000张票
    王9629买到了票编号:90001
    pool-1-thread-451 user time 3440

     

    这让我情何以堪,继续学习吧,是不是哪里写的不对啊,望程序员的小哥哥小姐姐临幸

     

    展开全文
  • 高并发模拟~多个线程同时发起请求

    千次阅读 2019-07-09 23:30:10
    高并发模拟,多个线程同时发起请求 两种方案: CyclicBarrier:栅栏,所有的线程必须同时到达栅栏位置,才能继续执行。 CountDownLatch:计数器,一个线程或多个线程一直等待,直到其他线程执行的操作完成。 1、...

    高并发模拟,多个线程同时发起请求

    两种方案:

    • CyclicBarrier:栅栏,所有的线程必须同时到达栅栏位置,才能继续执行。
    • CountDownLatch:计数器,一个线程或多个线程一直等待,直到其他线程执行的操作完成。

    1、CyclicBarrier

    • 适用在多线程相互等待,直到到达一个屏障点。并且CyclicBarrier是可重用的
    • 下面的列子,设置线程阻塞200个,但发起线程400个,这样会被分为两批,前200个线程相互等待,一起请求,后200个线程相互等待,一起请求。
    public class CurrentChatTest {
        
        //定义CyclicBarrier 的屏障,需要等多少个线程到了才发起请求
        CyclicBarrier cyclicBarrier = new CyclicBarrier(200);
    
        private void runThread() {
        //定义线程池
            ExecutorService executorService = Executors.newFixedThreadPool(400);
         //执行线程
            for (int i = 0; i < 400; i++) {
                executorService.submit(buildThread(i));
            }
        }
    
        private Thread buildThread(int i) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("Thread:" + Thread.currentThread().getName() + "准备...");
                        //cyclicBarrier一定要等到满200个线程到了才往后执行
                        cyclicBarrier.await();
                        System.out.println("Thread:" + Thread.currentThread().getName() + "开始执行");
                        //do something
    
                    } catch (Exception e) {
                        e.printStackTrace();
                    } 
                }
            });
            thread.setName("name:" + i);
            return thread;
        }
    
        public static void main(String[] args) {
            CurrentChatTest currentChatTest = new CurrentChatTest();
            currentChatTest.runThread();
        }
    }
    

    2、CountDownLatch

    CountDownLatch 就是一个计数器,让所有的线程等待,直到计数器的值为0时才让线程执行。

    public class CurrentChatTest {
    
        //定义一个CountDownLatch
        CountDownLatch countDownLatch = new CountDownLatch(1);
        
      public void countDownLatch() {
            ExecutorService executorService = Executors.newFixedThreadPool(10);
            for (int i = 0; i < 10; i++) {
                executorService.submit(createThread());
            }
            //计数器减一
            countDownLatch.countDown();
        }
    
        //创建线程
        private Thread createThread() {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("Thread: "+Thread.currentThread().getName()+", 准备...");
                        countDownLatch.await();
                        //do something
                        System.out.println("Thread: "+Thread.currentThread().getName()+", 开始...");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            return thread;
        }
    
        public static void main(String[] args) {
            CurrentChatTest currentChatTest = new CurrentChatTest();
            currentChatTest.countDownLatch();
        }
    }
    
    展开全文
  • 模拟高并发访问

    2017-07-25 14:56:27
    利用php自带函数 批处理url访问
  • 2017-03-18 回答多线程几乎是每一个程序猿在使用每一种语言时都会首先想到用于解决并发的工具(js程序员请回避),使用多线程可以有效的利用cpu资源(python例外)。然而多线程所带来的程序的复杂度也不可避免,尤其...
  • java高并发项目的demo

    2018-07-18 22:31:13
    秒杀项目代码:其中涉及高并发的处理其中使用了redis,rabbit MQ,页面静态化,分布式session,应用及的nginx的负载均衡
  • PHP模拟高并发

    千次阅读 2018-09-18 18:25:42
    简单模拟高并发 什么是高并发高并发(High Concurrency)是互联网分布式系统架构设计中必须考虑的因素之一,它通常是指,通过设计保证系统能够同时并行处理很多请求。 高并发相关常用的一些指标有响应时间...
  • 高并发模拟多个用户同时访问接口

    千次阅读 多人点赞 2020-07-09 19:01:56
    前些天客户需要测试一下接口可以承受多大的并发量!!! 当时就想到了countDownLatch,就小小的提了一下意见就被安排到我的头上! 废话就不多说了(为了不浪费你们的时间,先说好这代码是测试单个接口或者方法的并发...
  • 模拟高并发请求

    千次阅读 2017-03-12 21:55:47
    在程序开发中,需要进行测试时,对于代码在高并发请求时是否正确运行,需要进行一些测试。...可以利用apache本身提供的模拟高并发的工具,ab.exe > ab.exe -n 请求的次数 -c 多少人请求 被请求地址
  • 模拟高并发的原理就是:利用线程池去执行多个线程通过httpclient访问controllerpackage com.xtzn.utils;import com.alibaba.fastjson.JSONObject;import org.apache.http.client.config.RequestConfig;import org....
  • jmeter 模拟高并发

    千次阅读 2019-05-25 13:46:16
    下载jmeter ...模拟多线程高并发情况 新建线程组 1、右击Test plan 2、选择添加》线程》线程组 设置线程组 新建http请求 1、右击线程组 2、选择添加》取样器》http请求 设置http请求 ...
  • 模拟web高并发

    2017-12-29 14:45:00
    用ab爽得不要不要的。。。。。 转载于:https://www.cnblogs.com/silva/p/8144447.html
  • Java使用代码模拟高并发操作

    千次阅读 2018-10-17 16:18:34
    摘要:在java中,使用了synchronized关键字和Lock锁实现了资源的并发访问控制,在同一时间只允许唯一了线程进入临界区访问资源(读锁除外),这样子控制的主要目的是为了解决多个线程并发同一资源造成的数据不一致的...
  • 模拟多线程高并发测试

    千次阅读 2019-06-17 10:42:03
    public static void main(String[] args) { ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml"); BidInfoService bidInfoService = (BidInfoSe...
  • 实例1,使用CountDownLatch模拟高并发 场景化:有一道阻塞墙,站着一个管理员,手里拿着N(线程数)个牌子,到达一个线程,把牌子给该线程,当手里牌子都发完时,打开墙门,放行所有线程通过 package ...
  • Java模拟用户的高并发请求

    千次阅读 2018-04-26 13:31:09
    * 模拟用户的并发请求,检测用户乐观锁的性能问题 * * @author fxb * @date 2018/3/29 18:55 */ public class ConcurrentTest { final static SimpleDateFormat sdf= new SimpleDateFormat...
  • NULL 博文链接:https://gjp014.iteye.com/blog/2373086
  • JAVA 模拟瞬间高并发

    万次阅读 多人点赞 2014-10-21 17:48:58
    前些日子接到了一个面试电话,面试内容我印象很深,如何模拟一个并发?当时我的回答虽然也可以算是正确的,但自己感觉缺乏实际可以操作的细节,只有一个大概的描述。  当时我的回答是:“线程全部在同一节点wait,...
  • 模拟多线程高并发进行压力测试

    千次阅读 2020-03-14 16:19:32
    思路 第一种:线程池模拟200个线程——wait等待线程数达200——...两种方案都可以实现瞬时高并发模拟,但是建议使用第二种方案。 第一种方案中,压测过程中,wait状态下的线程已经释放对象上的锁定,唤醒时...
  • 项目背景:对web后端进行高并发的请求,简单测试服务框架的性能解决思路:利用python的多线程,但python的多线程有点“鸡肋”, 我的选择使用简洁轻便gevent。解决方案:采用gevent异步 + requests 进行高并发请求...
  • 高并发测试亲测可用

    2018-04-18 23:37:47
    用于高并发环境测试 需安装jdk>7,无需生成秘钥打开即可使用
  • springboot rabbitmq 模拟高并发秒杀系统,买不了吃亏
  • java模拟高并发请求

    千次阅读 2016-11-07 15:53:19
    实现高并发请求,即同一个进程开辟出多个线程请求相同的资源 ,再同时对一个资源进行访问操作。  我们都知道 要实现一个多线程的并发服务可以有两种方式,一种是继承 Theard 类 ,另一种是实现Runnable 接口 在java....
  • HTTP高并发测试工具

    2018-11-30 10:24:17
    HTTP高并发测试工具

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 118,144
精华内容 47,257
关键字:

高并发模拟