开源测试服务

• 终于测试完成了，也上线了，虽然有些曲折，一期目标基本达成。

项目地址：https://github.com/JunManYuan...，我以为出去测试框架部分的内容之外，有两个地方值得借鉴​。开发过程当中遇到的问题和写过的BUG都在测开笔记里面了，有兴趣能够一读。

号外：这个仓库里面都是一些开源测试框架和测试平台，你们有GitHub帐号的请不要吝啬星星。

多线程

多线程处理用例参数和执行用例场景下，线程池的引入。这个首先解决了多用例运行的耗时太多的问题，其次也解决了每次处理任务新建线程对于性能的消耗。

具体的方案就是新建一个全局的线程池，而后把全部多线程任务包装成一个线程对象，经过将任务丢到线程池中，而后经过CountDownLatch这个类实现等待执行结束，而后进行下一步操做。具体可参考：- CountDownLatch类在性能测试中应用。

核心代码以下：

线程池

package com.okay.family.common.threadpool;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 自定义线程池,用例批量运行用例,非并发测试线程池
 */
public class OkayThreadPool {

    private static ThreadPoolExecutor executor = createPool();

    public static void addSyncWork(Runnable runnable) {
        executor.execute(runnable);
    }

    private static ThreadPoolExecutor createPool() {
        return new ThreadPoolExecutor(16, 100, 10, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1000));
    }

}

多线程类：

package com.okay.family.common.threadpool;

import com.okay.family.common.basedata.OkayConstant;
import com.okay.family.common.bean.testcase.CaseRunRecord;
import com.okay.family.common.bean.testcase.request.CaseDataBean;
import com.okay.family.common.enums.CaseAvailableStatus;
import com.okay.family.common.enums.RunResult;
import com.okay.family.utils.RunCaseUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.concurrent.CountDownLatch;

public class CaseRunThread implements Runnable {

    private static Logger logger = LoggerFactory.getLogger(CaseRunThread.class);

    int envId;

    CaseDataBean bean;

    CaseRunRecord record;

    CountDownLatch countDownLatch;

    public CaseRunRecord getRecord() {
        return record;
    }

    private CaseRunThread() {

    }

    public CaseRunThread(CaseDataBean bean, CountDownLatch countDownLatch, int runId, int envId) {
        this.bean = bean;
        this.envId = envId;
        this.countDownLatch = countDownLatch;
        this.record = new CaseRunRecord();
        record.setRunId(runId);
        record.setUid(bean.getUid());
        record.setParams(bean.getParams());
        record.setCaseId(bean.getId());
        record.setMark(OkayConstant.RUN_MARK.getAndIncrement());
        bean.getHeaders().put(OkayConstant.MARK_HEADER, record.getMark());
        record.setHeaders(bean.getHeaders());
    }

    @Override
    public void run() {
        try {
            if (bean.getAvailable() == RunResult.USER_ERROR.getCode()) {
                record.fail(RunResult.USER_ERROR, bean);
            } else if (bean.getEnvId() != envId || bean.getAvailable() != CaseAvailableStatus.OK.getCode()) {
                record.fail(RunResult.UNRUN, bean);
            } else {
                RunCaseUtil.run(bean, record);
            }
        } catch (Exception e) {
            logger.warn("用例运行出错,ID:" + bean.getId(), e);
            record.fail(RunResult.UNRUN, bean);
        } finally {
            countDownLatch.countDown();
        }
    }


}

---

对于用户锁的实现

其中包括线程同步锁和分布式锁。之因此采用两个，主要是由于竞争中拿不到锁的时候，不会像业务开发那样直接丢出来拿锁失败的业务，而是须要等待其余线程安全对用户的验证以后，再取出最新的用户凭证。这里面涉及到的东西比较复杂，中间由于逻辑问题我也写了好几个BUG。

这里涉及的一些多线程编程的内容，还有在多用例执行的过程当中我用到ConcurrentHashMap做为缓存，第一是为了减小对数据库的读写。第二是为了防止用例中大量引用错误的用户致使执行时间变长。

核心代码以下：

/**
     * 获取用户登陆凭据,map缓存
     *
     * @param id
     * @param map
     * @return
     */
    @Override
    @Transactional(isolation = Isolation.REPEATABLE_READ)
    public String getCertificate(int id, ConcurrentHashMap<Integer, String> map) {
        if (map.containsKey(id)) return map.get(id);
        Object o = UserLock.get(id);
        synchronized (o) {
            if (map.containsKey(id)) return map.get(id);
            logger.warn("非缓存读取用户数据{}", id);
            TestUserCheckBean user = testUserMapper.findUser(id);
            if (user == null) UserStatusException.fail("用户不存在,ID:" + id);
            String create_time = user.getCreate_time();
            long create = Time.getTimestamp(create_time);
            long now = Time.getTimeStamp();
            if (now - create < OkayConstant.CERTIFICATE_TIMEOUT && user.getStatus() == UserState.OK.getCode()) {
                map.put(id, user.getCertificate());
                return user.getCertificate();
            }
            boolean b = UserUtil.checkUserLoginStatus(user);
            logger.info("环境:{},用户:{},身份:{},登陆状态验证:{}", user.getEnvId(), user.getId(), user.getRoleId(), b);
            if (!b) {
                updateUserStatus(user);
                if (user.getStatus() != UserState.OK.getCode()) {
                    map.put(id, OkayConstant.EMPTY);
                    UserStatusException.fail("用户不可用,ID:" + id);
                }
            } else {
                testUserMapper.updateUserStatus(user);
            }
            map.put(id, user.getCertificate());
            return user.getCertificate();
        }
    }
    
        /**
     * 更新用户登陆状态,全局锁+分布式锁
     *
     * @param bean
     * @return
     */
    @Override
    @Transactional(isolation = Isolation.REPEATABLE_READ)
    public int updateUserStatus(TestUserCheckBean bean) {
        int userLock = NodeLock.getUserLock(bean.getId());
        int lock = commonService.lock(userLock);
        if (lock == 0) {
            logger.info("分布式锁竞争失败,ID:{}", bean.getId());
            int i = 0;
            while (true) {
                SourceCode.sleep(OkayConstant.WAIT_INTERVAL);
                TestUserCheckBean user = testUserMapper.findUser(bean.getId());
                String create_time = user.getCreate_time();
                long create = Time.getTimestamp(create_time);
                long now = Time.getTimeStamp();
                if (now - create < OkayConstant.CERTIFICATE_TIMEOUT && user.getStatus() == UserState.OK.getCode()) {
                    bean.copyFrom(user);
                    return testUserMapper.updateUserStatus(bean);
                }
                if (i++ > OkayConstant.WAIT_MAX_TIME) {
                    UserStatusException.fail("获取分布式锁超时,没法更新用户凭据:id:" + bean.getId());
                }
            }
        } else {
            logger.info("分布式锁竞争成功,ID:{}", bean.getId());
            try {
                TestUserCheckBean user = testUserMapper.findUser(bean.getId());

                String create_time = user.getCreate_time();
                long create = Time.getTimestamp(create_time);
                long now = Time.getTimeStamp();
                if (bean.same(user) && StringUtils.isNotBlank(user.getCertificate())) {
                    if (now - create < OkayConstant.CERTIFICATE_TIMEOUT && user.getStatus() == UserState.OK.getCode()) {
                        bean.copyFrom(user);
                        return testUserMapper.updateUserStatus(bean);
                    }
                    if (UserUtil.checkUserLoginStatus(user)) bean.copyFrom(user);
                }
                UserUtil.updateUserStatus(bean);
                return testUserMapper.updateUserStatus(bean);
            } catch (Exception e) {
                logger.error("用户验证失败!ID:{}", bean.getId(), e);
                bean.setStatus(UserState.CANNOT.getCode());
                return testUserMapper.updateUserStatus(bean);
            } finally {
                commonService.unlock(userLock);
            }
        }
    }

---

• 公众号FunTester首发，更多原创文章：FunTester440+原创文章，欢迎关注、交流，禁止第三方擅自转载。

热文精选

• 接口功能测试专辑
• 性能测试专题
• 图解HTTP脑图
• 写给全部人的编程思惟
• 如何mock固定QPS的接口
• 手机号验证码登陆性能测试
• 2020年Tester自我提高
• 电子书网站爬虫实践
• 如何正确执行功能API测试
• 测试用例设计——一切测试的基础
• 将来的神器fiddler Everywhere