澳门美高梅手机网站智能硬件类产品测试项目总结

前言

本身是偏晚高开发的coder,学到python的这里时更的关注。操作系统的连锁接口在python是勿是于linux
C中而从简的差不多。OS的定义不说了,这次笔记集中关注python中几近进程、多线程、高并发、加锁同步、进程中通信等实现。

  一个产品的成色担保得通过一样系列系统、严格的测试项目来拓展把控,对于研发人员,针对产品所需要的测试项目及要求了然于胸非常有助于产品研发质量的升官,当你会得逞逃脱许多拧点,少过“坑”时,整个项目之研发周期将大大缩短。

Definition

进程(process),在本人的懂得中,就是一个任务,是一律段落运行的主次。后台的童鞋应该清楚该实质就是是一个task_struct结构体,里面记载着程序运行需要之有着资源与他自家的信。当他赢得运行所急需的内存、CPU资源相当,也就算是变成了一个running状态的进程。

足拿经过理解呢一个职责,那线程就是完结这任务之执行流。线程是CPU调度的极端小粒度。通常来说,现在之类面临,至少我沾的,一个经过面临还囊括在不断一个之线程。毕竟现在之OS都是SMP的,充分利用多中心加强程序效率应是每个coder敲键盘时要先考虑的。

  举行了这么久远之智能硬件类产品,现对其中心的、必须的测试项目类型总结如下:

多进程

linux的内核向外提供了 fork()
这个体系调用来创造一个按部就班进程的正片,当然往往fork()后还跟着 exec()
族系统调用,我们创建一个过程一般还是为推行外的代码程序。

python的 os
模块封装了多常用之系调用,可以说凡是python中尽常用的一个库了。举个栗子:

import os

print('Process (%s) start...' % os.getpid())

pid = os.fork()
if pid == 0:
    print('Child process (%s).' % os.getpid())
else:
    print('Parent process (%s).' %  pid)

fork() 会返回两单结实,父进程返回一个大于0之无符号数,子进程返回0。

咱们且知晓socket()是发出某些独步骤的,而对此web服务器,每天各时每分还有正重重的访请求。如果是一个经过向他提供服务,那就是这个历程也率先单用户从创造socket到关门,再为产一个用户提供服务。用户时时去掉着队接受劳务之,显然不切合逻辑。

拿Apache举个栗子,它是多进程架构服务器的代表。

  1. 运行主程序,只担负server端socket的listen()
    accept(),当然主进程是一个看护进程
  2. 每当一个用户请求服务,就会见调用fork(),在子程序中收受多少,read()或者write(),然后提供劳动直到关闭
  3. 预告进程或如当回收了之子进程资源的

伪代码如下:

import os

server_fd = socket()
bind(server_fd,ip,port)
listen(server_fd,MAX_PROCESS)
While Online:
    connfd = accpet(server_fd)
    for each connfd:
        os.fork()
        // TODO
close(server_fd)

地方就段先后只适用linux平台,windows平台创建过程的办法并无是 fork()
调用。python中提供了multiprocesssing模块来配合windows,比打fork(),代码的语义更好明一些

from multiprocessing import Process
import os

def run_proc(name):
    print('Child process %s (%s)...' % (name, os.getpid()))

if __name__=='__main__':
    print('Parent process %s.' % os.getpid())
    #创建Process实例
    p = Process(target=run_proc, args=('test',))
    print('Child process will start.')
    p.start()
    p.join()
    print('Child process end.')

这里的join语义和linux平台的多线程中的join语义很像,但成效实在是linux平台的wait

突发性要进程池,multiprocessing 也直提供了pool用于创造。

pool.apply(func,params) 是单进程阻塞模式
pool.apply_async(func,params,callback)  是多进程异步模式
pool.map(func,iter) 用于可迭代结构,阻塞式调用
pool.map_async(func,iter,callback)

貌似情形下,还是将过程数控制成跟CPU核数相同。pool结束调用pool.join()回收过程资源时,需要先pool.close()

方提到过,创建一个新过程的因反复是为了加载新的代码,去履行新的职责。所以python封装了fork()暨后来的exec族,提供subprocess模块,直接操作新的子进程。这个包,一般是故来推行标的指令或者程序一旦shell命令,和os.system()类似。

import subprocess

r = subprocess.call(['ls','-l'])    #阻塞
r = subprocess.call('ls -l',shell = True)
r = subprocess.check_call(['ls','-l'])  #returncode不为0则raise CalledProcessError异常
r = subprocess.check_output('ls -l',shell=True)
r = subprocess.Popen(['ls','-l'])   #非阻塞,需主动wait

r = subprocess.Popen(['ls','-l'],stdin=child1.stdout,stdout=subprocess.PIPE, stderr=subprocess.PIPE)    #设置标准输入输出出错的句柄
out,err = r.communicate()   #继续输入,或者用来获得返回的元组(stdoutdata,stderrdata)

手动继续输入的例子:

import subprocess

print('$ python')
p = subprocess.Popen(['python'], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
output, err = p.communicate(b"print('Hello,world')")
print(output.decode('utf-8'))
print('Exit code:', p.returncode)

============================================================================================

经过之中通信

multiprocessingQueue或者Pipe来帮助实现,类似linux中之Pipe,打开一修管道,一个进程往里扔数据,一个起另外一样条捡数据。python中之Pipe是全双工管道,既好读也得以写。可以透过Pipe(duplex=False)创半双工管道。

from multiprocessing import Pipe,Queue
#实例
q = Queue()
p = Pipe()
#写入数据
q.put(value)
p[0].send(value)
#读数据
q.get()
p[1].recv()

分级选举个例子,用Queue

from multiprocessing import Process, Queue
import os, time, random

def write(q):
    print('Process to write: %s' % os.getpid())
    for value in ['A','B', 'C']:
        print('Put %s to queue...' % value)
        q.put(value)
        time.sleep(random.random())

def read(q):
    print('Process to read: %s' % os.getpid())
    while True:
        value = q.get(True)
        time.sleep(random.random())
        print('Get %s from queue.' % value)

if __name__=='__main__':
    q = Queue()
    pw = Process(target=write, args=(q,))
    pr = Process(target=read, args=(q,))

    pw.start()
    pr.start()
    pw.join()
    pr.terminate()

用Pipe:

from multiprocessing import Process, Pipe
import os, time, random

def write(q):
    print('Process to write: %s' % os.getpid())
    for value in ['A','B', 'C']:
        print('Put %s to pipe...' % value)
        q.send(value)
        time.sleep(random.random())

def read(q):
    print('Process to read: %s' % os.getpid())
    while True:
        value = q.recv()
        time.sleep(random.random())
        print('Get %s from pipe.' % value)

if __name__=='__main__':
    p = Pipe()
    pw = Process(target=write, args=(p[0],))
    pr = Process(target=read, args=(p[1],))

    pw.start()
    pr.start()
    pw.join()
    time.sleep(2)
    pr.terminate()

基本功能

多线程

有人会有问号,问啊使以经过遭到初露多单线程,多创造几单经过同坐班不纵执行了。其实这样是足以的,只不过经过是单位发硌很,比较占资源,创建的早晚开销比较深(尤其在windows系统下),进程多矣CPU调度起来,在经过中切换为是颇耗时的。还有多任务并协作时,需要数交换,进程中通信也是开,而一个过程被的线程是共享进程的内存空间的,可以一直互动。所以现在大抵线程的程序更加普遍。

不过大多线程也是发生坏处的,协同协作之多线程,有一个悬了,会影响及拥有的任何线程,也尽管象征是职责是开不下来了。进程因为具备独立的地点空间,所以一个过程非常了对其它进程的熏陶好说不行粗。

python中提供了threading模块为多线程服务,threading.current_thread()回来时线程,主线程名也MainThread

import threading

thread = threading.Thread(target=func,args=())
thread.start()
thread.join()

基本上线程编程,最重大的哪怕联合和排斥,也即是各种锁之用法。为什么要为此锁,后台的童鞋应该都晓得,现在的SMP操作系统还是抢占式内核,也就算是就你不等之审核共同工作经常,很幸运的莫改乱一个共享变量,当然这即不容许了。当你的CPU时间片及时间了,或者需要内存还是IO资源,你受蹬来了CPU的干活行列,你要得在移动之上让您的资源将锁加上,下次重新来就开。线程同步的主要的凡针对性共享资源的判定,和挑选合适的沿。也便是针对什么资源加锁和用啊锁。

但是当python中好不满,多线程存在着原生态的毛病,因为兼具GIL的在,这是python解释器的筹划缺陷。导致python程序在让解说时,只能发出一个线程。不过,对于IO密集型的次,多线程的设计尚是殊有拉的。比如爬虫

  • 不过常用之缉,类似 mutex
  • 原则变量,threading.Condition()会见包含一个Lock目标,因为就两者一般都是相当使用的。
  • 信号量,threading.Semaphore()

import threading

lock = threading.Lock()
lock.acquire()
lock.realease()  #配合try...finally保证最后释放掉锁,防止死锁

cond = threading.Condition()
cond.wait()
cond.notify()   cond.notify_all()

sem = threading.Semaphore(NUM)
sem.acquire()
sem.realease()

event = threading.Event()   #相当于没有lock的cond
event.set(True)
event.clear()

若果以下的景

thread_func(params):
    web_res = params
    def func1(web_res):
        http = web_res.http
        TODO
    def func2(web_res):
        data = web_res.data
        TODO
    def func3(web_res):
        user = web_res.user
        TODO

以一个线程中,又存在多只子线程或者函数时,需要拿一个参数还传于其常。可以经唯一的id来区分出从全局变量自己的部分变量时。可以据此ThreadLocal实现

import threading 

student = threading.local()

def func(name):
    person = student.name  #需要之前关联过

p1 = threading.Thread(target=func,argc='A')
p1 = threading.Thread(target=func,argc='B')

经过ThredLocal免去了我们亲自去字典中存取。通常用于web开发被的为每个线程绑定一个数据库连接,HTTP请求,用户身份信息相当。

基本操作功能

分布式进程

分布式是为了当横向上提升全体系统的负荷能力。python中multiprocessing模块中之manage子模块支持将多进程分布至不同之机械及。当然肯定是一个master进程来担负任务的调度。依赖manage子模块,可以生自在的形容来分布式程序。

依照爬虫,想使爬下豆瓣或者知乎这样网站的全体数量,用单机估计得费好几年。可以将需要爬的网站的有所URL放在一个Queue中,master进程负责Queue的田间管理,可以将过多装置和master进程所于的装置建立联系,爬虫开始获得URL时,都由主机器获取。这样便会管协同不冲突之合作。

性能参数测试:静态功耗测试、输入频率波动测试

联网控制:基本功能控制、掉电应力测试、无线通讯距离测试

滥用测试

电池寿命测试

 

条件耐受性能

高低温耐受能力:高温工作45℃、低温工作-20℃、低温存储和启动-40℃、高温存储75℃

湿热耐受能力:高温高湿工作45℃/95%

耐老化性能:常温环境带来载n个钟头

耐盐雾性能

防尘防水(IP)性能

标附着力测试

 

EMC

辐射骚扰试验(RE)

传骚扰试验(CE)

谐波电流试验(HC)

静电放电抗扰度试验(ESD)

电快速瞬变脉冲群抗扰度试验(EFT/B)

浪涌冲击抗扰度试验(SURGE)

电压暂降、短时中断、电压变化抗扰度试验(DIPS)

射频辐射电磁场抗扰度试验(RS)

喷洒频场感应传导骚扰抗扰度试验(CS)

工频磁场抗扰度试验(PFMF)

 

对抗机械应力冲击测试

按键力度和寿命测试

插拔力度测试

随着电器寿命测试

扭力测试

单机跌落

抵制冲击性(IK)

包跌落测试

包裹震动测试

 

安规测试

温升测试

耐压测试

绝缘测试

保险丝(过温/过压/过流)

漏电流测试

保安接地测试

活动保护

故障测试

防火测试

 

活认证

CCC

FCC

CE

ROHS

============================================================================================

依附产品测试项目思维导图一客:

澳门美高梅手机网站 1

发表评论

电子邮件地址不会被公开。 必填项已用*标注