并发与迭代

Posted 2023-05-11

参考技术A 例如在LR里，我要测100个用户同时并发登陆所用时间，那我是不是在录制好脚本后，需要参数化“用户名”，

“密码”以及在那个记事本里构造100个真实的用户名和密码？ 然后运行Controller，

设置用户数为100？那么这里的迭代次数该怎么设啊，设成1和设成10有什么区别啊？

我老是搞不清测试并发用户，“迭代”和“并发用户数”（就是controller里设的虚拟用户数）的区别。

ZEE的回答：

用比喻的方式来回一下：

四车道的马路，如果只有四辆车并排走过就是并发；

              如果四辆车排成一纵队走过就是迭代；

              如果有100辆车排成25行依次走过就是并发加迭代。

在以上说法中，只有并排的车是我们设置的用户数。

通过用lr做负载压力测试过程发现，如果设定不同的action迭代次数，每次得出的结果是不同的，曲线的表现形式也是不同的。

这点就使我们会感觉困惑,为什么要设置action的迭代次数？以及对于不同的应用系统应该怎样设置迭代次数呢？

首先你要理解性能测试是在干什么？

性能测试是模拟系统一段时间内真实的压力情况，以考察系统的性能。

再看怎么模拟系统真实的压力情况？比如在半个小时内，用户都在进行登录操作，且平均分布在这半个小时内。我们要做的是什么？

模拟这半个小时用户的行为。怎么模拟？估算出同时操作的人数，并用LoadRunner不断的发送登录请求，这就是我们为什么要迭代。

至于迭代次数，只要能够模拟出真实情况，多少次都无所谓，不过10次8次估计是模拟不出来。

迭代次数至少要保证压力达到一个稳定值后再运行一段时间，这样我们得到的数据才是有效的。

所以我们除非是特别要求，一般不用迭代次数，而是用运行时间。

1，迭代和并发，是完全不同的概念。没有什么关系。

比如，一个用户迭代十次，还是一个用户的压力。

10个用户执行一次，就是10个用户的压力。10个用户迭代10次，还是10个用户的压力。但他们都和参数化的数据有关系

（也要看参数化是如何设置的，以及系统如何判断提交值的）。

2,你要是想知道，LR是如何实现迭代和并发：

说一个比较容易理解的层面：迭代就是不停的反复调用同一脚本，反复执行，注意，

对1个用户执行10次来说，只会分配一块内存。

10个用户执行一次，是调用同一脚本10次，会分配10块内存。

LR调用脚本，编译后，运行，按脚本发送数据。

比如：web_url这样的函数，执行就会发HTTP request。

如果你还想知道更细节的进程和函数的实现，只能侧面验证（具体方法看各人的能力和擅长），因为我们都不是LR的开发者。

3,太显然的问题了，参数化时选择每次出现唯一，只要参数够用就OK，不够用，就设置相应的规则。

action在场景运行中iteration只对其起作用，对vuser_init和vuser_end都不起作用，

action是一个可以被重复使用的最小单位其实你可以将所有脚本录制到一个action里，只是不方便管理罢了。

举个最简单的例子，

像lr自带的例子——订票系统，你如果把所有脚本都录制到一个action里，

那回放的时候，每个用户登录就只能买一张票，而如果想一个用户买多张票的话，这样就行不通了。

那你就要设多个action，并把登录和结束各录制在一个action里，把买票录到一个action中，

这样，将买票的action迭代多次，而用户登录和结束只运行一次，这不就模拟了现实中的情况了吗？

其实LoadRunner 是以客户端的角度来定义“响应时间”的，

当客户端请求发出去后， LoadRunner 就开始计算响应时间，一直到它收到服务器端的响应。

这个时候问题就产生了：如果此时的服务器端的排队队列已满，服务器资源正处于忙碌的状态，

那么该请求会驻留在服务器的线程中，换句话说，这个新产生的请求并不会对服务器端产生真正的负载，

但很遗憾的是，该请求的计时器已经启动了，因此我们很容易就可以预见到，

这个请求的响应时间会变得很长，

甚至可能长到使得该请求由于超时而失败。

等到测试结束后，

我们查看一下结果，就会发现这样一个很不幸的现象：

事务平均响应时间很长，最小响应时间与最大响应时间的差距很大，

而这个时候的平均响应时间，其实也就失去了它应有的意义。

也就是说，由于客户端发送的请求太快而导致影响了实际的测量结果，

设置步长则可以缓解这一情况，这样，应该试试设置pacing，再运行看看情况。

并发用户数量，有两种常见的错误观点。

一种错误观点是把并发用户数量理解为使用系统的全部用户的数量，理由是这些用户可能同时使用系统；

还有一种比较接近正确的观点是把用户在线数量理解为并发用户数量。

实际上，在线用户不一定会和其他用户发生并发，例如正在浏览网页的用户，对服务器是没有任何影响的。

但是，用户在线数量是统计并发用户数量的主要依据之一。

并发主要是针对服务器而言，是否并发的关键是看用户操作是否对服务器产生了影响。

因此，并发用户数量的正确理解为：在同一时刻与服务器进行了交互的在线用户数量。

这些用户的最大特征是和服务器产生了交互，这种交互既可以是单向的传输数据，也可以是双向的传送数据。

比如说：有一个这样的场景，系统在线用户是100个，但是同时操作某一个事物（比如说登陆操作）的人是20个那么场景怎么设计了？

在Controller中设置100个虚拟用户执行这个脚本，然后登陆操作之前放一个集合点，然后设置集合点的策略（20个用户到达时即执行集合点）

对于多个业务场景, 只要录制多个脚本放在同一个场景内, 然后分配不同比例的虚拟用户就可以了,

如果不想跑哪个业务场景, 那就不选中这个脚本即可.

追问

并发用户数，我可不可以在采集的时候理解为最大的允许vuser值

回答

某个脚本设置的vuser值, 可以理解为这个业务场景的并发用户数,但如果要测试具体某个业务的并发操作,  那就需要设置集合点,

而且集合点数目不能大于vuser值.

　LoadRunner是怎么重复迭代和怎么增加并发运行的呢？

　　另外，在参数化时，对于一次压力测试中均只能用一次的资源应该怎么参数化呢？就是说这些资源用了一次就不能在用了的。

　　－－参数化时,在select  next row选择unique,update value on选择 each occurence,

　　1. 迭代跟虚拟用户数没什么必然联系

　　迭代是这样的：

　　迭代1次  迭代2次  迭代3次

　　用户1    X1          X2            X3

　　用户2    Y1          Y2            Y3

　　其中的X1-3 Y1-3是参数，参数规则就是二楼说的

　　这么两个用户是根据你的rump up 上来的，比如5秒上两个用户，那么用户1和2就在5秒之内加载进来的，不知道说清楚了没。

　　第二个问题就简单了，只能用一次的参数，首先确保你的参数足够，另外规则选择的时候，注意选择唯一

　　迭代次数只是对你设置了迭代次数的action进行迭代，而用户数可以理解为对整个录制过程的迭代（只是各个用户不同）

    而且增加并发量可以通过增加用户来达到　还可以设置集合点来增加某个操作的并发量

　　假如一个脚本，设置最大并发量为10，每5秒中增加2个并发用户，而Action设置的迭代为10次：

　　当开始至2秒时，加载了2个用户，这2个用户分别开始运行，并都运行10次，不管这个2个用户运行10次是否结束，当下一个2两秒到来时，

    即开始至第4秒时又加载了2个用户，这2个又运行10次；就这样一直加载到10个并发用户，然后当每个用户都运行完10次时就结束。

　　这样中间最大并发是10个，但不一定能达到10个，因为在加载最后几个时，前面的有可能已经运行结束，

    所以如果要真正达到最大并发10就必须设置集合点来完成

　　不过也不一定非要设置集合点才能实现同时处在running的状态有10个用户。

　　设置duration也是可以的。不过那就不只每个用户运行10次了。

　　如果想实现用户迭代10次，并且想同时running为10个用户，就应该设置集合点。

　　迭代（Iterate）设计，或者我们称之为增量（Incremental）设计的思想和XP提倡的Evolutionary Design有异曲同工之妙。

并发编程：同步类容器与并发类容器

1、同步类容器

同步类容器都是线程安全的，但在某些场景下可能需要加锁来保护复合操作。

复合操作，如：

  迭代（反复访问元素，遍历完容器中所有的元素）

  跳转（根据指定的顺序找到当前元素的下一个元素）

  条件运算

这些复合操作在多线程并发的修改容器时，可能会表现出意外的行为，最经典的就是ConcurrentModificationException，原因是当容器迭代的过程中，被并发的修改了内容，这是由于早期迭代器设计的时候并没有考虑并发修改的问题。

同步类容器：如古老的Vector、HashTble。这些容器的同步功能其实都是有JDK的Collections.synchronized**等工厂方法去创建实现的，其底层的机制无非就是用传统的synchronized关键字对每个公用的方法都进行同步，使得每次只能有一个线程访问容器的状态，这明显不能满足当前互联网时代高并发的需求，在保证线程安全的同时，也必须有足够好的性能。 --- 使用并发类容器

2、并发类容器

jdk5以后提供了多种并发类容器来替代同步类容器从而改善性能。同步类容器的状态都是串行化的，他们虽然实现了线程安全，但是严重降低了并发性，在多线程环境时，严重降低了应用程序的吞吐量。

并发类容器是专门针对并发设计的，使用ConcurrentHashMap来代替给予散列的传统的HashTable，而且在ConcurrentHashMap中，添加了一些常见复合操作的支持，以及使用了CopyOnWriteArrayList代替Vctor，并发的CopyOnWriteArraySet，以及并发的Queue，ConcurrentLinkedQueue和LinkedBlockingQueue，前者是高性能的队列，后者是以阻塞形式的队列，具体实现Queue还有很多，例如ArrayBlockingQueue、PrioityBlockingQueue、SynchronousQueue等。

2.1 ConcurrentMap

ConcurrentMap接口下有两个重要的实现：

  ConcurrentHashMap

  ConcurrentSkipListMap(支持并发排序功能，弥补ConcurrentHashMap)

ConcurrentHashMap内部使用段（Segment）来表示这些不同的部分，每一个段其实就是一个小的HashTable，它们有自己的锁。只要多个修改操作发生在不同的段上，它们就可以并发进行。把一个整体分成了16个段（Segment），也就是最高支持16个线程的并发修改操作。这也是在多线程场景时减小锁的粒度从而降低锁竞争的一种方案。并且代码中大多共享变量使用volatile关键字声明，目的是第一时间获取修改的内容。

2.2 Copy-On-Write容器

copy-on-write简称COW，是一种用于程序设计的优化策略。

JDK里的COW容器有两种：CopyOnWriteArrayList和CopyOnWriteArraySet

什么是CopyOnWrite容器？

 CopyOnWrite容器即写时复制的容器。通俗的理解是当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行Copy，复制出一个新的容器，然后新的容器里添加元素，添加完之后，再将原容器的引用指向新的容器。这样做的好处是我们可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器。

下面我们看一下CopyOnWriteArrayList的add源码：

public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

这里采用了重入锁，当一个线程执行add操作的时候，先要获取这把锁

本文出自 “我爱大金子” 博客，请务必保留此出处http://1754966750.blog.51cto.com/7455444/1910174