qileilove

用python做测试实现高性能测试工具(5)—多进程写log

在上一篇中解决了系统的性能问题，但写log又引入了问题，多进程写log会引起混乱。

　　查询了多进程写log 的方案，主要有2种：

　　利用多进程的Queue,把log放到统一的有个log queue里面，一个单独的线程写log

　　起一个单独的socket server,由这个server来接受log，并负责写log

　　我觉得这2重方案都太重了，很多写log的地方就需要改动了，希望找到一个方案能直接不改动老代码写log的方式，开始考虑的是每个进程单独写一个log,但这样统计数据有点小不方便。继续探索到，有个开源的项目(https://launchpad.net/python-concurrent-log-handler)，已经实现了多进程写log，但目前只是实现了按文件大小RotatingFileHandler，按时间rotate 的功能还没实现。不过这个已经足够用了。

try:

from cloghandler import ConcurrentRotatingFileHandler as RFHandler

except ImportError:

from warnings import warn

warn("ConcurrentLogHandler package not installed. Using builtin log handler")

from logging.handlers import RotatingFileHandler as RFHandler

rotateHandler = RFHandler("sim.log", "a", 10*1024*1024, 5)

formatter = logging.Formatter('%(asctime)s [%(processName)s %(threadName)s %(levelname)s %(module)s:%(lineno)d] %(message)s')

rotateHandler.setFormatter(formatter)

log = logging.getLogger()

log.addHandler(rotateHandler)

log.setLevel(20)

rotateHandler = RFHandler("sim.log", "a", 10*1024*1024, 5)

　　log文件名为sim.log, 文件到10M就会rotate, 最多保留5个文件

　　formatter = logging.Formatter('%(asctime)s [%(processName)s %(threadName)s %(levelname)s %(module)s:%(lineno)d] %(message)s') 设置log输出的格式，包括时间，进程名，线程名，模块名字，代码行数

　　log.setLevel(20) 设置什么级别的log输出， CRITICAL 50; ERROR 40; WARNING 30; INFO 20; DEBUG 10, NOSET 0;

import logging

import time

import multiprocessing

class Customer(multiprocessing.Process):

def __init__(self,mp_name):

multiprocessing.Process.__init__(self,name=mp_name)

def run(self):

while 1:

logging.debug(" I am here")

time.sleep(1)

for i in xrange(2):

mp=Customer("customer"+str(i))

mp.start()

　　最后输出log的例子是：

2013-12-05 21:42:10,961 [customer0 MainThread DEBUG testqueue_old:115] I am here

2013-12-05 21:42:15,361 [customer1 MainThread DEBUG testqueue_old:115] I am here

用python做测试实现高性能测试工具(4)—系统架构

posted @ 2014-01-08 10:43 顺其自然EVO 阅读(2122) | 评论 (0) | 编辑收藏

数据库乱码的小技巧

最近用ssh框架和mysql数据库写项目的时候，老是出现中文乱码，根据网上的各种终极策略，使用spring自带的字符过滤器啊，设置页面编码啊，设置数据库编码啊都设置好为UTF-8了，还是出现中问乱码，后来在spring的配置文件applicationContext.xml中的配置数据源中的数据库url地址时加上?characterEncoding=utf8后解决了这个问题。

　　原来的是：

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"

destroy-method="close">

　　改成：

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"

destroy-method="close">

posted @ 2014-01-08 10:42 顺其自然EVO 阅读(201) | 评论 (0) | 编辑收藏

Java中ArrayList和LinkedList区别

一般大家都知道ArrayList和LinkedList的大致区别：

　　1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。

　　2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。

　　3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。

　　ArrayList和LinkedList是两个集合类，用于存储一系列的对象引用(references)。例如我们可以用ArrayList来存储一系列的String或者Integer。那么ArrayList和LinkedList在性能上有什么差别呢？什么时候应该用ArrayList什么时候又该用LinkedList呢？

　　一．时间复杂度

　　首先一点关键的是，ArrayList的内部实现是基于基础的对象数组的，因此，它使用get方法访问列表中的任意一个元素时(random access)，它的速度要比LinkedList快。LinkedList中的get方法是按照顺序从列表的一端开始检查，直到另外一端。对LinkedList而言，访问列表中的某个指定元素没有更快的方法了。

　　假设我们有一个很大的列表，它里面的元素已经排好序了，这个列表可能是ArrayList类型的也可能是LinkedList类型的，现在我们对这个列表来进行二分查找(binary search)，比较列表是ArrayList和LinkedList时的查询速度，看下面的程序：

package testlist;

import java.util.LinkedList;

import java.util.List;

import java.util.Random;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

public class TestList {

public static final int N = 50000;

public static List<Integer> values;

static {

Integer vals[] = new Integer[N];

Random r = new Random();

for (int i = 0, currval = 0; i < N; i++) {

vals[i] = new Integer(currval);

currval += r.nextInt(100) + 1;

}

values = Arrays.asList(vals);

}

static long timeList(List<Integer> lst) {

long start = System.currentTimeMillis();

for (int i = 0; i < N; i++) {

int index = Collections.binarySearch(lst, values.get(i));

if (index != i)

System.out.println("***错误***");

}

return System.currentTimeMillis() - start;

}

public static void main(String args[]) {

System.out.println("ArrayList消耗时间：" + timeList(new ArrayList<Integer>(values)));

System.out.println("LinkedList消耗时间：" + timeList(new LinkedList<Integer>(values)));

}

　　我得到的输出是：

　　ArrayList消耗时间：31

　　LinkedList消耗时间：30688

　这个结果不是固定的，但是基本上ArrayList的时间要明显小于LinkedList的时间。因此在这种情况下不宜用LinkedList。二分查找法使用的随机访问(random access)策略，而LinkedList是不支持快速的随机访问的。对一个LinkedList做随机访问所消耗的时间与这个list的大小是成比例的。而相应的，在ArrayList中进行随机访问所消耗的时间是固定的。

　　如果只是遍历一下：

packagetestlist;

importjava.util.LinkedList;

importjava.util.List;

importjava.util.Random;

importjava.util.ArrayList;

importjava.util.Arrays;

publicclassTestList{

publicstaticfinalintN=50000;

publicstaticList<Integer>values;

static{

Integervals[]=newInteger[N];

Randomr=newRandom();

for(inti=0,currval=0;i<N;i++){

vals[i]=newInteger(currval);

currval+=r.nextInt(100)+1;

}

values=Arrays.asList(vals);

}

staticlongtimeList(List<Integer>lst){

longstart=System.currentTimeMillis();

for(inti=0;i<lst.size();i++){

lst.get(i);

}

returnSystem.currentTimeMillis()-start;

}

publicstaticvoidmain(Stringargs[]){

System.out.println("ArrayList消耗时间："+timeList(newArrayList<Integer>(values)));

System.out.println("LinkedList消耗时间："+timeList(newLinkedList<Integer>(values)));

}

　　输出：

　　ArrayList消耗时间：0

　　LinkedList消耗时间：1703

　　这是否表明ArrayList总是比LinkedList性能要好呢？这并不一定，在某些情况下LinkedList的表现要优于ArrayList，有些算法在LinkedList中实现时效率更高。比方说，利用Collections.reverse方法对列表进行反转时，其性能就要好些。

　　看这样一个例子，加入我们有一个列表，要对其进行大量的插入和删除操作，在这种情况下LinkedList就是一个较好的选择。请看如下一个极端的例子，我们重复的在一个列表的开端插入一个元素：

package testlist;

import java.util.ArrayList;

import java.util.LinkedList;

import java.util.List;

public class ListDemo {

static final int N = 50000;

static long timeList(List<Object> list) {

long start = System.currentTimeMillis();

Object o = new Object();

for (int i = 0; i < N; i++)

list.add(0, o);

return System.currentTimeMillis() - start;

}

public static void main(String[] args) {

System.out.println("ArrayList耗时：" + timeList(new ArrayList<Object>()));

System.out.println("LinkedList耗时：" + timeList(new LinkedList<Object>()));

}

　　这时我的输出结果是：

　　ArrayList耗时：1813

　　LinkedList耗时：0

　　这和前面一个例子的结果截然相反，当一个元素被加到ArrayList的最开端时，所有已经存在的元素都会后移，这就意味着数据移动和复制上的开销。相反的，将一个元素加到LinkedList的最开端只是简单的未这个元素分配一个记录，然后调整两个连接。在LinkedList的开端增加一个元素的开销是固定的，而在ArrayList的开端增加一个元素的开销是与ArrayList的大小成比例的。

　　二．空间复杂度

　　在LinkedList中有一个私有的内部类，定义如下：

private static class Entry<E> {

E element;

Entry<E> next;

Entry<E> previous;

Entry(E element, Entry<E> next, Entry<E> previous) {

this.element = element;

this.next = next;

this.previous = previous;

}

　　每个Entry对象reference列表中的一个元素，同时还有在LinkedList中它的上一个元素和下一个元素。一个有1000个元素的LinkedList对象将有1000个链接在一起的Entry对象，每个对象都对应于列表中的一个元素。这样的话，在一个LinkedList结构中将有一个很大的空间开销，因为它要存储这1000个Entity对象的相关信息。

　　ArrayList使用一个内置的数组来存储元素，这个数组的起始容量是10.当数组需要增长时，新的容量按如下公式获得：新容量=(旧容量*3)/2+1，也就是说每一次容量大概会增长50%。这就意味着，如果你有一个包含大量元素的ArrayList对象，那么最终将有很大的空间会被浪费掉，这个浪费是由ArrayList的工作方式本身造成的。如果没有足够的空间来存放新的元素，数组将不得不被重新进行分配以便能够增加新的元素。对数组进行重新分配，将会导致性能急剧下降。如果我们知道一个ArrayList将会有多少个元素，我们可以通过构造方法来指定容量。我们还可以通过trimToSize方法在ArrayList分配完毕之后去掉浪费掉的空间。

　　三．总结

　　ArrayList和LinkedList在性能上各有优缺点，都有各自所适用的地方，总的说来可以描述如下：

　　1．对ArrayList和LinkedList而言，在列表末尾增加一个元素所花的开销都是固定的。对ArrayList而言，主要是在内部数组中增加一项，指向所添加的元素，偶尔可能会导致对数组重新进行分配；而对LinkedList而言，这个开销是统一的，分配一个内部Entry对象。

　　2．在ArrayList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在LinkedList的中间插入或删除一个元素的开销是固定的。

　　3．LinkedList不支持高效的随机元素访问。

　　4．ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间

　　可以这样说：当操作是在一列数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList会提供比较好的性能；当你的操作是在一列数据的前面或中间添加或删除数据,并且按照顺序访问其中的元素时,就应该使用LinkedList了。

posted @ 2014-01-08 10:41 顺其自然EVO 阅读(197) | 评论 (0) | 编辑收藏

Spring集成TestNg测试

　1，在eclipse中安装TestNg插件，这里省略。。

　　2，编写测试spring Dao层的代码

package test.com.smart.dao;

import com.smart.dao.UserDao;

import com.smart.domain.User;

import com.smart.service.UserService;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.testng.AbstractTestNGSpringContextTests;

import org.testng.annotations.Test;

import java.util.Date;

import static org.testng.Assert.assertEquals;

import static org.testng.Assert.assertNotNull;

import static org.testng.Assert.assertTrue;

@ContextConfiguration(locations = {"classpath:resources/applicationContext.xml"})

public class UserDaoTest extends AbstractTestNGSpringContextTests {

@Autowired

private UserDao userDao;

@Test

public void hasMatchUser() {

int count = userDao.getMatchCount("admin1", "123456");

assertTrue(count>0);

}

@Test

public void findUserByUserName() {

User user = userDao.findUserByUserName("admin");

assertNotNull(user);

assertEquals(user.getUserName(), "admin");

}

　　注意：@ContextConfiguration(locations = {"classpath:resources/applicationContext.xml"})这个注解是的localtion属性使用的是src类路径下面的

　resources/applicationContext.xml spring配置文件

　　2，由于TestNg测试持久层和测试服务层十分类似，这里省略了，这里给出测试层的代码

　　a,项目编写封装了客户端请求的类

package com.smart.web;

public class LoginCommand {

private String userName;

private String password;

public String getPassword() {

return password;

}

public void setPassword(String password) {

this.password = password;

}

public String getUserName() {

return userName;

}

public void setUserName(String userName) {

this.userName = userName;

}

　　b.下面编写控制类的代码

package com.smart.web;

import java.util.Date;

import javax.servlet.http.HttpServletRequest;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Controller;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.servlet.ModelAndView;

import com.smart.domain.User;

import com.smart.service.UserService;

@Controller

@RequestMapping(value = "/admin")

public class LoginController {

@Autowired

private UserService userService;

@RequestMapping(value = "/login.html")

public String loginPage() {

return "login";

}

@RequestMapping(value = "/loginCheck.html")

public ModelAndView loginCheck(HttpServletRequest request, LoginCommand loginCommand) {

boolean isValidUser =

userService.hasMatchUser(loginCommand.getUserName(),

loginCommand.getPassword());

if (!isValidUser) {

return new ModelAndView("login", "error", "用户名或密码错误。");

} else {

User user = userService.findUserByUserName(loginCommand

.getUserName());

user.setLastIp(request.getLocalAddr());

user.setLastVisit(new Date());

userService.loginSuccess(user);

request.getSession().setAttribute("user", user);

return new ModelAndView("main");

}

c,编写好控制类的代码，我们就可以测试这个控制类了，下面的代码是使用TestNg测试controller十分正确

package test.com.smart.web;

import com.smart.domain.User;

import com.smart.web.LoginController;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.mock.web.MockHttpServletRequest;

import org.springframework.mock.web.MockHttpServletResponse;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.testng.AbstractTestNGSpringContextTests;

import org.springframework.test.util.ReflectionTestUtils;

import org.springframework.web.client.RestTemplate;

import org.springframework.web.servlet.HandlerMapping;

import org.springframework.web.servlet.ModelAndView;

import org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter;

import org.testng.annotations.BeforeMethod;

import org.testng.annotations.Test;

import static org.testng.Assert.assertEquals;

import static org.testng.Assert.assertNotNull;

import static org.testng.Assert.assertNull;

@ContextConfiguration(locations = {"classpath:applicationContext.xml","file:d:/actionSpring/chapter/chapter1/src/main/webapp/WEB-INF/viewspace-servlet.xml"})

public class LoginControllerTest extends AbstractTestNGSpringContextTests {

@Autowired

private AnnotationMethodHandlerAdapter handlerAdapter;

@Autowired

private LoginController controller;

//声明Request与Response模拟对象

private MockHttpServletRequest request;

private MockHttpServletResponse response;

//执行测试前先初始模拟对象

@BeforeMethod

public void before() {

request = new MockHttpServletRequest();

request.setCharacterEncoding("UTF-8");

response = new MockHttpServletResponse();

request.setAttribute(HandlerMapping.INTROSPECT_TYPE_LEVEL_MAPPING, true); //Spring3.1 存在的BUG

}

// 测试LoginController#loginCheck()方法

@Test

public void loginCheck() throws Exception {

//测试登陆成功的情况

request.setRequestURI("/admin/loginCheck.html");

request.addParameter("userName", "admin"); // 设置请求URL及参数

request.addParameter("password", "123456");

//向控制发起请求 ” /loginCheck.html”

ModelAndView mav = handlerAdapter.handle(request, response, controller);

User user = (User) request.getSession().getAttribute("user");

assertNotNull(mav);

assertEquals(mav.getViewName(), "main");

assertNotNull(user);

request.getSession().removeAttribute("user");

//测试登陆失败的情况

request.setRequestURI("/admin/loginCheck.html");

request.addParameter("userName", "test");

request.addParameter("password", "123456");

mav = handlerAdapter.handle(request, response, controller);

user = (User) request.getSession().getAttribute("user");

assertNotNull(mav);

assertEquals(mav.getViewName(), "login");

assertNull(user);

}

　　注意：

@ContextConfiguration(locations = {"classpath:applicationContext.xml","file:d:/actionSpring/chapter/chapter1/src/main/webapp/WEB-INF/viewspace-servlet.xml"}) 这个注解可以整合多个spring配置文件中"file:d:/actionSpring/chapter/chapter1/src/main/webapp/WEB-INF/viewspace-servlet.xml"表示的是文件系统的形式给出配置文件

posted @ 2014-01-07 10:48 顺其自然EVO 阅读(7111) | 评论 (0) | 编辑收藏

用python做测试实现高性能测试工具(4)—系统架构

在前面一篇中，不知道我文章中有神马关键字，图片总是上传不成功，为了大家看的方便，在这里上传

　　多线程的系统架构：

　　多线程改成多进程，只要把红线部分的线程改成多进程即可，但总的进程数最好不要超过CPU 核数。

用python做测试实现高性能测试工具(3)—优化系统架构

posted @ 2014-01-07 10:45 顺其自然EVO 阅读(247) | 评论 (0) | 编辑收藏

Selenium2.0测试工程的搭建

　早前针对Selenium1.0搭建过一次测试环境，时至多日，有点忘却了，正好出了新版本，闲来无事，基于Selenium2.0版本重新搭建一次，顺便记录下，给日后的我或者你做个参考。

　　1. 安装jdk并配置环境变量：

　　jdk需要安装1.6版本或以上的，安装目录为默认路径

　　环境变量配置如下：

　　JAVA_HOME=C:\Program Files\Java\jdk...

　　本人安装的是1.7.0版本，所以JAVA_HOME=C:\Program Files\Java\jdk1.7.0，此外，

　　CLASSPATH=%JAVA_HOME%\lib\tool.jar

　　PATH=%JAVA_HOME%\bin

　　2. 创建一个C#工程（工作中使用C#），在工程中引入下图标注红色框的dll

3. 编写代码（最简单的实现：能打开百度IE浏览器）

using OpenQA.Selenium;

using OpenQA.Selenium.IE;

using OpenQA.Selenium.Support.UI;

using OpenQA.Selenium.Remote;

public void Test()

{

// 打开浏览器

RemoteWebDriver driver = new InternetExplorerDriver();

// 打开测试页面

driver.Navigate().GoToUrl(@"http://www.baidu.com");

// 关闭浏览器

driver.Quit();

driver = null;

}

原创作品，转载时请务必以超链接形式标明本文原始出处、作者信息和本声明，否则将追究法律责任。

posted @ 2014-01-07 10:45 顺其自然EVO 阅读(274) | 评论 (0) | 编辑收藏

MySQL数据库出现大量Locked的一个案例

做为一款轻量级数据库软件，MySQL在使用过程中遇到访问速度慢，或者无法响应这类的问题，解决方式基本都有定式，一般第一反应都会是登录到MySQL, show processlist看看当前连接状态。

　　虽说简单，但show processlist显示的信息确实是相当有用，有一回，三思收到反馈说MySQL查询很慢，于是，赶紧登录到mysql中，执行show processlist查看当前连接信息：

mysql> show processlist;

+--------+-------------+--------------------+-------+---------+-------+----------------------------------+----------------------------------------------------------------------------------+

+--------+-------------+--------------------+-------+---------+-------+----------------------------------+----------------------------------------------------------------------------------+

................

　　一堆的Locked，怪不得慢啊，阻塞的时间不短了，十几分钟。

　　通常来说存在Locked就说明当前读写操作存在被阻塞的情况，一般我们看到锁都会下意识认为是由于写阻塞了读，上面的结果看仿佛也符合这一特征：只有一条UPDATE，而无数条的SELECT。猜是必须的，但不能瞎猜，这毕竟是线上系统，就算想杀连接的线程，也是要杀掉造成阻塞的那个，不能把所有Locked的全杀了，不然DBA本人很快也要被人杀了，因此具体情况如何还是需要继续分析。

　　从show processlist查看到的信息来看，UPDATE的语句是很简单的，分析a的表结构，该表为MyISAM表，ID为该表主键，该条更新应该能够瞬间执行完，即使系统繁忙也不应该，而且通过查看当前的系统状态，整体负载很低，iostat中看I/Owait几可忽略，该写操作不太可能这么长时间都没有执行完。

　　这个时候再分析show processlist中显示的信息，发现id 123890的语句执行时间最长，肯定是在该UPDATE语句之前执行的，通过show full processlist查看语句详表，看到该查询也访问到了a表，经此分析，应该是该语句长时间的读阻塞了写，而被阻塞的写操作由于处于最优先处理队列，又阻塞了其它的读。

　　不过这些都还只是我们的推论，考虑到线上系统服务的可靠性，最好还是能找到更确切的证据，而后再做操作。

mysqladmin命令有一个debug参数，可以分析当前MySQL服务的状态信息，同时也可以用来帮助我们定位当前锁的详细情况，这里我们通过该命令分析一下当前MySQL服务的详细状态，执行mysqladmin命令如下：

　　[root@phpmysql02 data]# mysqladmin -ujss -p -S /data/3306/mysql.sock debug

　　Enter password:

　　debug会将状态信息生成到mysql的错误文件，一般锁的信息都会保存在最后几行，这里我们在操作系统层error log最后几行：

[root@phpmysql02 data]# tail -10 phpmysql02.err

Thread database.table_name Locked/Waiting Lock_type

2 hdpic.t_wiki_zutu Waiting - write Highest priority write lock

123890 hdpic.t_wiki_zutu_category Locked - read Low priority read lock

123890 hdpic.t_wiki_zutu_photo Locked - read Low priority read lock

123890 hdpic.t_wiki_zutu Locked - read Low priority read lock

124906 hdpic.t_wiki_zutu Waiting - read Low priority read lock

　　从上述信息可以看出，123890持有的读锁阻塞了2的写入和124906的读操作，这个状态符合我们的推论，接下来处理就比较单纯了，如果现状不可接受，不能继续等待，将123890杀掉，释放资源即可：

　　mysql> kill 123890;

　　Query OK, 0 rows affected (0.00 sec)

　　再次执行show processlist查看：

mysql> show processlist;

+--------+-------------+--------------------+-------+---------+--------+----------------------------------+------------------+

+--------+-------------+--------------------+-------+---------+--------+----------------------------------+------------------+

| 124906 | hdpic_read | 192.168.1.39:18844 | hdpic | Sleep | 1 | | NULL |

| 124912 | hdpic_read | 192.168.1.39:18862 | hdpic | Sleep | 2 | | NULL |

| 124914 | hdpic_read | 192.168.1.39:18865 | hdpic | Sleep | 1 | | NULL |

| 124917 | hdpic_read | 192.168.1.39:18875 | hdpic | Sleep | 1 | | NULL |

| 124919 | hdpic_read | 192.168.1.39:18877 | hdpic | Sleep | 2 | | NULL |

................

　　已经没有Locked的连接，此时向前端人员询问，告知响应慢的现象也已经消除，服务恢复正常。

posted @ 2014-01-07 10:44 顺其自然EVO 阅读(263) | 评论 (0) | 编辑收藏

SQL数据库性能测试，插入数据

SQL Server中，测试插入大量数据，执行时间。

declare @begin_date datetime

declare @end_date datetime

select @begin_date = getdate()

declare @counter int

set @counter=0

while(@counter < 1000000)

begin

INSERT INTO testsql.dbo.Errorlog VALUES(''+@counter+'','b','c','d','e','f')

set @counter=@counter + 1

end

select @end_date = getdate()

select datediff(ms,@begin_date,@end_date) as '用时/毫秒'

--1====3

--10====3

--100===20

--1000===300

--10000===2490

--100000===30000

--1000000===328936

--10000000===

--29513

--31416

--30066

--31326

declare @begin_date datetime

declare @end_date datetime

select @begin_date = getdate()

select COUNT(tid) from errorlog

select @end_date = getdate()

select datediff(ms,@begin_date,@end_date) as '用时/毫秒'

posted @ 2014-01-06 14:02 顺其自然EVO 阅读(184) | 评论 (0) | 编辑收藏

Java中读取文件进度条的实现

　实现功能描述：

　　当读取一个大文件时，一时半会儿无法看到读取结果，就需要显示一个进度条，是程序员明白已经读了多少文件，可以估算读取还需要多少时间。

　　实现这个功能比较简单，用到的类有两个：ProgressMonitorInputStream（主要是整个类）和 ProgressMonitor ，它们在javax.swing中

　　大体思路，你要首先知道整个文件的大小，和当前已经读取文件的大小，获得整个文件大小的方法

ProgressMonitorInputStream monitor;

/**

* @param 表示此进度条要依附在哪个组件上

* @param 显示在此进度条上的消息

* @param 需要监控的输入流

monitor = new ProgressMonitorInputStream(null, "Loading ",new FileInputStream("filename path"));

int all = monitor.available();//整个文件的大小

int in = monitor.read(data);//每次读取文件的大小

　　例如：你每次读一行str=in.readLine();则data=str.instr.getBytes()+1;这里+1，主要是为了获得换行符的字节数，否则，最后获得的进步无法达到100%

　　int readed=0;//表示已经读取的文件

　　reader+=in;//累加读取文件大小

　　计算进度：

　　float process = (float) readed / all * 100;// 算出百分比

　　窗口显示：

　　progressMonitor.setNote("archived " + process + " %");// 显示在进度条上

posted @ 2014-01-06 14:01 顺其自然EVO 阅读(371) | 评论 (0) | 编辑收藏

用python做测试实现高性能测试工具(3)—优化系统架构

　　在上一篇中对代码进行了优化，离需求进了一步，但还是很大距离，代码进一步优化我也不知道怎么办了，不会高深的算法。只能从改进系统架构考虑。

　　方案3：改变系统架构

　　在开始多进程之前，先简单说明一下python GIL, 之前自己对他也有些误解。因为python GIL的机制存在，同时运行的线程只有一个，但这个线程在不同时刻可以运行在不同的核上，这个调度是由操作系统完成的，如果你写个死循环，开的线程足够多，是可以把整个系统的CPU消耗干净的，此时你在Linux下通过top可以看到，us 占用的CPU不大，但sy占用的CPU会很大，CPU主要消耗在系统调度上了。下面是测试代码，大家可以试试。

import threading

class MultipleThread(threading.Thread):

def __init__(self):

threading.Thread.__init__(self)

def run(self):

while 1:

print "here"

for i in xrange(100):

multiple_thread=MultipleThread()

multiple_thread.start()

multiple_thread.join()

　　既然因为GIL的存在，同时只能运行一个线程，那多线程可以提高效率，当然可以！开个3-4个线程可以明显的提高性能，大概能提高个2-3倍左右吧，但继续增加线程就是副作用了。

　　系统多线程的系统架构：

　　发送和接受都不存在瓶颈，主要瓶颈在在红线部分，decode和 encode部分。多线程改成多进程比较简单，工作量不大，只要把需要多进程共享的信息，由Queue改成multiprocessing.Queue()就可以了，把继承的DiameterMsgParser(threading.Thread)改成DiameterMsgParser(multiprocessing.Process)，有个比较麻烦的是log的输出，python自带的logging模块在多进程下写同一个文件会引起混乱。这个在后面单独说明。

import multiprocessing

import logging

class Worker(multiprocessing.Process):

def __init__(self,mp_name,input_queue):

multiprocessing.Process.__init__(self,name=mp_name)

self.input_queue=input_queue

def run(self):

for i in xrange(100):

self.input_queue.put_nowait(i)

logging.debug("test "+str(i))

　　多线程改成多进程后，在sunfire 4170 (16 core , 2.4G ) 上能支持到5000 meesages (双向)， CPU占有率 30-40%，用的是标准的python2.7，因为在solaris上没安装成功pypy,所以在此机器上，我没有测试pypy对性能影响多大。但我在一个2核的linux机器上测试python和 pypy,在多进程的情况下的效率，pypy对效率的提升没有达到倍数的级别，没找到什么原因, 后面有CPU核数比较多的机器再测试下。

用python做测试实现高 性能测试工具(2)—优化代码

posted @ 2014-01-06 14:00 顺其自然EVO 阅读(306) | 评论 (0) | 编辑收藏

仅列出标题

用python做测试实现高性能测试工具(5)—多进程写log

数据库乱码的小技巧

Java中ArrayList和LinkedList区别

Spring集成TestNg测试

用python做测试实现高性能测试工具(4)—系统架构

Selenium2.0测试工程的搭建

MySQL数据库出现大量Locked的一个案例

SQL数据库性能测试，插入数据

Java中读取文件进度条的实现

用python做测试实现高性能测试工具(3)—优化系统架构

导航

统计

常用链接

留言簿(55)

随笔分类

随笔档案

文章分类

文章档案

搜索

最新评论

阅读排行榜

评论排行榜