python-高级编程-03

【多进程与多线程】

调度：在传统计算机操作系统中 cpu的调度的基本单位是进程，随着线程的引入，线程变成操作系统的最小调度单位

而进程是作为资源的拥有单位。

并行：由于线程的引入原先一个进程只能有一个并发现在一个进程可以有多个线程并行执行，

　　早起的httpserver 都是通过线程来解决服务器的并发比起之前用fork子进程来处理并发效率有很大的提升。

　　这一切得益于线程可以用进程更低的代价实现并发。

共享：一般linux线程会让线程继承或共享如下资源

。进程的共有数据内存

。进程所打开的文件描述符

。信号的处理器

。进程用户的ID和进程组ID

隔离：

。线程ID ，在linux中线程和进程共享ID空间

　　　　。寄存器的值

　　　　。线程的栈

　　　　。优先级 linux的系统设计使得线程和进程除了在某些资源的共享和隔离有差异外，几乎是一视同仁的，他们可以有不同观点priority

我们在选择多进程还是多线程的时候需要根据业务场景使用。他们特性就是共享和隔离的区别。

【Linux的进程】

Linux在linus设计的时候的定位就是一个多任务的操作系统，从linux出的第一个版本的时候就有了进程的概念，

　　线程的产生是为了解决并发问题，线程的定位也就是更小更轻的进程

　　一些问题：

为什么不能一味的开线程解决并发问题？

　　　　#线程的上下文切换所带来的消耗，开的线程越多，在上下文切换过程中消耗就越大，核心就是内存根不上cpu的速度。　　　　

　　上下文切换：在cpu还是单核的时候，计算机操作系统就已经实现了多任务系统，但是你要知道单核的cpu在同一时间段内

　　　　　　　只能执行某一个进程的某一个指令，为了达到多任务的执行效果，linux把cpu的时间切成大小不到等的时间

　　　　　　　　片，通过内核调度算法，让进程一个个上去跑，由于切换时间片的时间非常短，在我们人类看来计算机在同时执行多个程序。

　　　　　　那么这个是如果实现的呢，如果程序到了时间片结束之后还没有完成它的工作，那么操作系统会把这个程序，以及其依赖的数据

　　　　　　　都保存在内存里，然后回到进程的队列里。保存现场是需要代价的，这将极大的影响cpu的分支预测，影响系统性能，

　　　　　　　所以频繁的上下文切换，是我们及其避免的。

【协程】

　　协程就是用户自己在进程中控制多任务的栈，尽可能的不让进程由于外部中断或者IO的等待丧失CPU调度的时间片，从而在进程内部实现并发。

【内存与守护进程】　　　　

程序运行时的内存，也就是我们在用户状态能看到的内存地址，都不是物理内存的地址，现代操作系统都会在物理内存上做一层，内存映射，每个

进程内的内存空间都是独立的

守护进程的特点：

　　1 后台运行，也不占用conscle的前面也就是bash里运行程序后面加个&

　　2 成为 process group leader 守护进程的父进程是init的那个进程

　　3 成为 session leader 一个ssh登陆会启动一个bash bash会fork很多子进程，这些进程轮流接受tty输出，这都是一个session session leader就是一队进程的父进程

　　4 fork 一次到两次因为linux父进程只对子进程负责，fork两次可以保证不影响正在执行的程序，直接交给init

　　5 chdir到/ 防止占用别的路径的 working dir的id 导致block不能

　　6 需要重置umask 方式后续子进程继承非默认umask造成不可控问题

　　7 处理标准输入输出错误输出（0，1，2）重定向stdout stderr stdin 防止tty中断后的broken pipe信号

8 日志输入重定向后，需要有办法反映内部情况

--关于僵尸进程--父进程派生出子进程如果子进程挂了但是一般进程父进程会拿着子进程的pid 调用wait，如果父进程对子进程没有处理，这个这个时候就会变成僵尸进程

如果父进程也挂了init会回收僵尸进程而僵尸进程存的就是僵尸进程退出的退出码。

【用python写一个守护进程】

#!/usr/bin/env python

#coding=utf-8

import os,sys

import time

'''

使用python写个守护进程

'''

def daemonzie(stdin='/dev/null',stdout='/dev/null',stderr='/dev/null'):

    try:

        pid = os.fork()

        if pid >0:

            sys.exit(0)

    except OSError ,e:

        sys.stderr.write("fork #2 failed (%d) %s\n "%(e.errno,e.strerror))

        sys.exit(1)

    os.chdir('/')# chdir到/ 防止占用别的路径的 working dir的id 导致block不能

    os.umask(0)#需要重置umask 方式后续子进程继承非默认umask造成不可控问题

    os.setsid()#成为  process group leader 守护进程的父进程是init的那个进程

    try:

        pid = os.fork()

        if pid >0:

            sys.exit(0)

    except OSError,e:

        sys.stderr.write("fork #2 failed (%d) %s\n " % (e.errno, e.strerror))

        sys.exit(1)

    for i in sys.stdout,sys.stderr:i.flush()

    si = open(stdin,'r+')

    so = open(stdout,'a+')

    se = open(stderr,'a+',0)

    os.dup2(si.fileno(),sys.stdin.fileno())

    os.dup2(so.fileno(), sys.stdin.fileno())

    os.dup2(se.fileno(), sys.stdin.fileno())

def main():

    import time

    sys.stdout.write('Daemon started with pid %s\n'%os.getpid())

    sys.stdout.write('Daemon stdout output\n')

    sys.stderr.write('Daemon stderr output\n')

    c = 0

    while 1:

        sys.stdout.write('%d:%s\n'%(c,time.ctime()))

        sys.stdout.flush()

        c + c+1

        time.sleep(1)

if __name__ == '__main__':

    daemonzie('/dev/null','/tmp/daemon_stdout.log','/tmp/daemon_error.log')

    main()

　说白了我们写一个 while 1 :print 'xxxx' 这种其实就是守护进程的基础我们需要对一些东西进行处理后才能形成一个正常的守护进程

【多线程实例】

#!/usr/bin/env python

#coding:utf-8

import thread

def f(name):

    #定义线程函数

    print 'this is '+name

if __name__ == '__maim__':

    thread.start_new_thread(f,("thread1",))

    while 1:

        pass

#/usr/bin/env python

#coding:utf-8

import  threading

class Th(threading.Thread):

    def __init__(self,name):

        threading.Thread.__init__(self)

        self.t_name = name

    def run(self):

        print "this is " + self.t_name

if __name__ == '__main__':

    thread1= Th("Thread1")

    thread1.start()

threading.Thread 类的可继承函数
getName() 获得线程对象名称
setName() 设置线程对象名称

join() 等待调用的线程件数后再运行的命令

setDaemin(bool)阻塞模式
　　True 父线程不等待子线程的结束
　　False 等待默认为等待
isDaemon() 判断子线程是否和父线程一起结束 即setDaemon（） 设置的值
isAlive()判断线程是否在运行

import threading

import time

class my_therad(threading.Thread):

    def __init__(self,thread_name):

        threading.Thread.__init__(self)

        self.setName=(thread_name)

    def run(self):

        print 'this is thread'+ self.getName()

        for i in range(5):

            time.sleep(1)

            print(str(i))

        print self.getName()+'is over'

if __name__ == '__main__':

    thread1 = my_therad('T1')

    thread1.start()

    #thread1.join()

    print 'main thread is over'

　这里如果加了join()

this is threadThread-1

0

1

2

3

4

Thread-1is over

main thread is over

　如果没加

this is threadThread-1

 main thread is over

0

1

2

3

4

Thread-1is over

　加了join 主线程会等待子线程结束返回之后才会执行

-------------------------------------------------------------------

import threading

import time

class my_therad(threading.Thread):

    def __init__(self,thread_name):

        threading.Thread.__init__(self)

        self.setName=(thread_name)

    def run(self):

        print 'this is thread'+ self.getName()

        for i in range(5):

            time.sleep(1)

            print(str(i))

        print self.getName()+'is over'

if __name__ == '__main__':

    thread1 = my_therad('T1')

    thread1.setDaemon(True)

    thread1.start()

    #thread1.setDaemon(True)

    #thread1.join()

    print 'main thread is over'

　　如果setDaemon 在start之前那么主线程不会等待子线程，直接结束了

输出：

起多个子线程

if __name__ == '__main__':

    for i in range(3):

        t = my_therad(str(i))

        t.start()

    print 'main thread is over'

　　【线程锁】

import  threading

import time

class Th(threading.Thread):

    def __init__(self,thread_name):

        threading.Thread.__init__(self)

        self.setName(thread_name)

    def run(self):

        threadLock.acquire()

        print "this is thread "+self.getName()

        for i in range(3):

            time.sleep(1)

            print str(i)

        print self.getName()+'  is over'

        threadLock.release()

if __name__ == '__main__':

    threadLock = threading.Lock()

    thread1 = Th('Thread_1')

    thread2 = Th('Thread_2')

    thread1.start()

    thread2.start()

　　如果加上锁输出就是这样

this is thread Thread_1

0

1

2

Thread_1  is over

this is thread Thread_2

0

1

2

Thread_2  is over

如果不加

this is thread Thread_1

 this is thread Thread_2

0

 0

1

 1

2

 Thread_2  is over

2

Thread_1  is over

　　在thread中优先会让之前拿到锁的人去拿锁这样可以保证cpu分支预测的成功率

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

#!/usr/bin/env python

#coding:utf-8

#####################

# time:2017-08-11   #

#####################

'''

this class is Daemon class

'''

import os,sys,time,atexit

from signal import SIGTERM

class Daemon():

    def __init__(self,pidfile = 'nbmon.pid',stdin='/dev/null',stdout='nbmon.log',stderr ='nbmon.log'):

        self.stdin = stdin

        self.stdout =stdout

        self.stderr = stderr

        self.pidfile = pidfile

    def daeminize(self):

        try:

            pid = os.fork()

            if pid > 0:

                sys.exit(0)

        except OSError ,e:

            sys.stderr.write("fork #1 failed:%d(%s)"(e.errno,e.strerror))

            sys.exit(1)

        os.chdir('/')

        os.setsid()

        os.umask(0)

        try:

            pid = os.fork()

            if pid > 0:

                sys.exit(0)

        except OSError ,e:

            sys.stderr.write("fork #2 failed:%d(%s)"(e.errno,e.strerror))

            sys.exit(1)

        sys.stdout.flush()

        sys.stderr.flush()

        si= file(self.stdin,'r')

        so= file(self.stdout,'a+')

        se = file(self.stderr,'a+',0)

        os.dup2(si.fileno(),sys.stdin.fileno())

        os.dup2(si.fileno(),sys.stdout.fileno())

        os.dup2(si.fileno(),sys.stderr.fileno())

        atexit.regoster(self.delpid)

        pid = str(os.getpid())

        file(self.pidfile,'w+'.write("%s\n"%pid))

    def delpid(self):

        os.remove(self.pidfile)

    def start(self):

        try:

            pf = file(self.pidfile,'r')

            pid = int(pf.read().strip())

            pf.close()

        except IOError,e:

            pid = None

        if pid :

            message = "pidfile %s alreadly exit,Daemon is running\n"

            sys.stderr.write(message % self.pidfile)

            sys.exit(1)

        self.daemonize()

        self.run()

    def stop(self):

        try:

            pf = file(self.pidfile,'r')

            pid = int(pf.read().strip())

            pf.close

        except IOError:

            pid = None

        if not pid:

            message = "pidfile %s does not exitst,Daemon is running\n"

            sys.stderr.write(message % self.pidfile)

            return

        try:

            while 1:

                os.kill(pid,STGTERM)

                time.sleep(0.1)

        except OSError,err:

            err = str(err)

            if err.find("No such process") > 0 :

                if os.path.exists(self.pidfile):

                    os.remove(self.pidfile)

            else:

                print srt(err)

                sys.exit(1)

    def restart(self):

        self.stop()

        self.start()

    def run(self):

        pass

#!/usr/bin/env  python

#coding:utf-8

from daemon import Daemon

import socket

import time

html= """HTTP/1.1 200 OK\r\nContent-Type: image/jpeg\r\nConnection: close\r\nContent-Length: """

html404 =  """HTTP/1.1 404 Not Found\r\nContent-Type: text/html\r\nContent-Length: 13\r\n\r\n<h1>404 </h1>"""

class agentD(Daemon):

    def run(self):

        listen_fd = socket.socket(socket.AF_INET,socket.SOCK_STREAM, 0)

        listen_fd.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

        listen_fd.bind(("0.0.0.0",9085))

        listen_fd.listen(10)

        while True:

            conn,addr  = listen_fd.accept()

            print "coming",conn,addr

            read_data = conn.recv(10000)

            try:

                pic_name = read_data.split(" ")[1][1:]

                print pic_name,'*********'

                with file(pic_name) as f:

                    pic_content = f.read()

                    lengths = len(pic_content)

                    print lengths,"####"

                    html_resp = html

                    html_resp += "%d\r\n\r\n" % (lengths)

                    print html_resp

                    html_resp += pic_content

            except:

                print "404 occur"

                html_resp = html404

            while len(html_resp)>0:

                sent_cnt = conn.send(html_resp)

                print "sent:",sent_cnt

                html_resp = html_resp[sent_cnt:]

            conn.close()

if __name__ == '__main__':

    agentd = agentD(pidfile = 'agent.pid',stdout='agent.log',stderr ='agent.log')

    agentd.run()

巴特西

python-高级编程-03

最新文章

热门文章