网络编程(八)

内核 ----》操作系统的核心代码

并发 ： 同时处理多个请求，但是内核采用轮询时间片的方式逐个访问，某一时间点实际只处理一个任务。

比如 ：IO多路复用   协程   循环服务器。单线程

并行 ： 使用多个内核，同时执行多个任务

比如 ： 多进程  多线程


计算机原理   算法导论 
python程序员  python开发者  
掘金

线程  threading.Thread

进程和线程的同步互斥
Event   Lock

**********************************************
condition   条件变量 

创建条件变量对象
con =  threading.Condition()

con.acquire() : 对资源加锁，加锁后其他位置再加锁则阻塞
con.release() : 解锁

con.wait()  : wait函数只能在 加锁的状态下使用。 wait函数会先解锁（release），然后让线程处于等待通知的阻塞状态

con.notify()  : 发送通知，线程接收到通知后 结束wait阻塞，并且执行 acquire 加锁操作


threadpool 第三方模块

python线程之GIL 
（全局解释器锁）
python  ---》 支持多线程 ---》同步互斥 ---》加锁 ---》 超级锁 ----》 在同一时刻，解释器只能解释一个线程 -----》大量python库为了省事沿用了这种方法 ---》python 多线程效率低下

GIL 问题 ： 由于python的全局解释器锁造成python的多线程执行效率低下

解决方法 ： 
* 不使用线程，使用多进程
* 不使用c  c++ 做解释器   C#   java
* python线程适合高用时的IO操作，网路IO。不适合cpu密集型程序

GIL带来的影响
单进程
Line cpu: 6.7326600551605225
Line IO: 3.783463478088379

多线程
Thread cpu 6.855324745178223
Thread IO 4.32829213142395

多进程
Process cpu 3.297400951385498
Process IO 1.6371185779571533


设计模式

设计模式代表了一种最佳实践，是被开发人员长期总结，用来解决某一类问题的思路方法。这些方法保证了代码的效率也已于理解

单例模式    工厂模式    生产者模式。。。。

生产者消费者

控制数据资源数量
降低耦合度

多个消费者  消耗
多个生产者  生产 
均对仓库资源进行操作

总结：
1. 进程线程区别和联系
2. 同步互斥的意义和实现方法
3. 进程线程使用什么样的方式通信
4. 进程线程的特点和选择 
5. 简单的设计模式的理解  
6. 僵尸进程，进程状态， GIL等概念的理解


服务器模型

硬件服务器 ： 主机  集群
IBM   HP 

软件服务器 ： 网络服务器 在后端提供网络功能，逻辑处理，数据处理的程序或者架构等
例如  httpserver   django   flask

服务器架构 : c/s（客户端服务器）   
             b/s（浏览器服务器） 
                   服务器的组织形式

服务器追求 ： 处理速度快，数据更安全，并发量大

硬件 ： 更高配置，更多主机，集成，分布
软件 ： 程序占有更少的资源，更流畅的运行，处理更多的并发

基本的服务器模型

循环   并发模式    IO多路复用

循环 ： 单线程程序 ，循环接收连接或者请求，然后处理，处理后继续循环

缺点 ： 不能同时处理多个客户端的并行，不允许某个客户端长期占有服务器

结构比较简单，适用于UDP程序，要求处理请求可以很快完成

IO多路复用模型：通过同时监控多个IO 来达到IO并发的目的。

缺点 ： 也是单线程，不能够长期阻塞。不适合处理大量cpu占有高的程序

开销小，比较适合IO密集型的服务端程序，

并行服务器： 每有一个客户端连接请求，就创建一个新的进程或者线程处理客户端的请求，而主进程/主线程可以继续接受其他客户端的连接

缺点 ： 资源消耗比较大
客户端需要长期占有服务器的情况

基于fork的多进程并发

1.创建套接字  绑定   监听
2.接受客户端请求
3.创建子进程处理客户端请求，父进程继续准备接受新的客户端连接
4.客户端退出，销毁相应的子进程

TFTP文件服务器

文件的上传，下载，和服务端文件库的查看

服务端       客户端
             1.查看文件库中有哪些文件
             2.下载文件到本地

确定技术 

fork --- 多进程
tcp  socket

os.listdir(path)
获取该文件夹下所有文件，形成一个列表

os.path.isfile(path)
os.path.isdir(path)
判断一个文件是否是普通文件/文件夹

作业 ： 完成tftp文件服务器  get 和 put功能

**********************************************************************
import threading
import time
import datetime

num = 0

#条件变量
con = threading.Condition()

class Gov(threading.Thread):
    def run(self):
        global num
        con.acquire()
        while True:
            print("开始拉升股市")
            num += 1
            print("拉升到 %d 个点"%num)
            time.sleep(2)
            if num == 5:
                print('暂时安全!')
                con.notify()
                print("不操作状态")
                con.wait()
        con.release()

class Consumers(threading.Thread):
    def run(self):
        global num
        con.acquire()
        while True:
            if num > 0:
                print("开始打压股市")
                num -= 1
                print("下降到%d个点"%num)
                time.sleep(2)
                if num == 0:
                    print("天台在哪")
                    con.notify()
                    print("不能在下降了")
                    con.wait()
        con.release()

t1 = Gov()
t2 = Consumers()
t1.start()
t2.start()

**********************************************************************************
import multiprocessing as mp
from signal import *
import os
from time import sleep

def saler_handler(sig,frame):
    if sig == SIGINT:
        os.kill(os.getppid(),SIGUSR1)
    elif sig == SIGQUIT:
        os.kill(os.getppid(),SIGUSR2)
    elif sig == SIGUSR1:
        print("到站了,请下车")
        os._exit(0)

def driver_handler(sig,frame):
    if sig == SIGUSR1:
        print("老司机,开车了")
    elif sig == SIGUSR2:
        print("车速有点快,系好安全带")
    elif sig == SIGTSTP:
        os.kill(p.pid,SIGUSR1)

#售票员
def saler():
    signal(SIGINT,saler_handler)
    signal(SIGQUIT,saler_handler)
    signal(SIGUSR1,saler_handler)
    signal(SIGTSTP,SIG_IGN)
    while True:
        sleep(2)
        print("Python 带你去远方")

p = mp.Process(target = saler)
p.start()

signal(SIGUSR1,driver_handler)
signal(SIGUSR2,driver_handler)
signal(SIGTSTP,driver_handler)
signal(SIGINT,SIG_IGN)
signal(SIGQUIT,SIG_IGN)
p.join()

**********************************************************************************
from socket import *
import os,sys
import signal

#创建套接字
HOST = ""
PORT = 8888

def client_handler(c):
    try:
        print("子进程接受客户的请求",c.getpeername())
        while True:
            data = c.recv(1024).decode()
            if not data:
                break
            print(data)
            c.send(b"receive your message")
    except (KeyboardInterrupt,SystemExit):
        raise
    except Exception as e:
        print(e)
    c.close()
    sys.exit(0) # 结束子进程

s = socket()
s.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
s.bind((HOST,PORT))
s.listen(5)

print("父进程 %d 等待客户端链接"%os.getpid())
while True:
    try:
        c,addr = s.accept()
    except KeyboardInterrupt:
        raise
    except Exception as e:
        print(e)
        continue
    #为新的客户端创建进程

    #处理僵尸进程
    signal.signal(signal.SIGCHLD,signal.SIG_IGN)

    pid = os.fork()
    if pid < 0:
        print("创建子进程失败")
        c.close()
        continue
    elif pid == 0:
        s.close()
        #处理客户端请求
        client_handler(c)
    else:
        c.close()
        continue

**********************************************************************************
from threading import Thread
#python标准库队列
import queue
from  time  import sleep

#创建一个队列作为仓库
q = queue.Queue()

#生产者
class Producer(Thread):
    def run(self):
        count = 0
        while True:
            if q.qsize() < 50:
                for i in range(3):
                    count += 1
                    msg = "产品 %d"%count
                    q.put(msg) #将产品放入队列
            sleep(1)

#消费者
class Customer(Thread):
    def run(self):
        while True:
            if q.qsize() > 20:
                for i in range(2):
                    msg = q.get() #从仓库拿货
                    print("消费了%s"%msg,
                        "还有%d个"%q.qsize())
            sleep(1)
#创建两个生产
for i in range(2):
    p = Producer()
    p.start()
#创建三个消费
for i in range(3):
    c = Customer()
    c.start()

**********************************************************************************
from socket import *
import sys
import time

#客户请求类
class TftpClient(object):
    def __init__(self,sockfd):
        self.sockfd = sockfd

    def do_list(self):
        self.sockfd.send(b'L') #发送请求类别

        #服务器回复 Y / N
        data = self.sockfd.recv(1024).decode()
        if data == 'Y':
            data = self.sockfd.recv(4096).decode()
            files = data.split('#')
            for file in files:
                print(file)
            print("文件列表展示完毕")
        else:
            print("请求文件列表失败")

    def do_get(self,filename):
        pass
    def do_put(self,filename):
        pass
    def do_quit(self):
        self.sockfd.send(b"Q")
        self.sockfd.close()
        sys.exit(0)

def main():
    if len(sys.argv) < 3:
        print("argv is error")
        sys.exit(1)
    HOST = sys.argv[1]
    PORT = int(sys.argv[2])
    ADDR = (HOST,PORT)
    BUFFERSIZE = 1024
    sockfd  = socket()
    sockfd.connect(ADDR)

    #创建客户请求对象
    tftp = TftpClient(sockfd)

    while True:
        print("========命令选项========")
        print("******** list **********")
        print("******* get file *******")
        print("******* put file *******")
        print("******** quit **********")
        print("========================")
        data = input("输入命令>>")
        if data.strip() == "list":
            tftp.do_list()
        elif data[:3] == "get":
            filename = data.split(' ')[-1]
            tftp.do_get(filename)
        elif data[:3] == "put":
            filename = data.split(' ')[-1]
            tftp.do_put(filename)
        elif data.strip() == "quit":
            tftp.do_quit()
        else:
            print("请输入正确的命令!!!")

if __name__ == "__main__":
    main()

**********************************************************************************
from socket import *
import os,sys
import signal
import time

#文件库位置
FILE_PATH = "/home/tarena/pythonweb/day3/"

class TftpServer(object):
    def __init__(self,connfd):
        self.connfd = connfd

    def do_list(self):
        filelist = os.listdir(FILE_PATH)
        if not filelist:
            self.connfd.send(b'N')
            return
        else:
            self.connfd.send(b"Y")
        time.sleep(0.1)
        files = ""
        for filename in filelist:
            if filename[0] != '.' and os.path.isfile(FILE_PATH + filename):
                files = files + filename + '#'

        self.connfd.send(files.encode())

    def do_get(self):
        pass
    def do_put(self):
        pass

def main():
    if len(sys.argv) < 3:
        print("argv is error")
        sys.exit(1)
    HOST = sys.argv[1]
    PORT = int(sys.argv[2])
    ADDR = (HOST,PORT)
    BUFFERSIZE = 1024

    sockfd  = socket()
    sockfd.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
    sockfd.bind(ADDR)
    sockfd.listen(5)
    signal.signal(signal.SIGCHLD,signal.SIG_IGN)

    while True:
        try:
            connfd,addr = sockfd.accept()
        except KeyboardInterrupt:
            sockfd.close()
            sys.exit(0)
        except Exception:
            continue
        print("客户登录:",addr)
        pid = os.fork()
        if pid < 0:
            print("创建子进程失败")
            connfd.close()
            continue
        elif pid == 0:
            sockfd.close()
            #创建客户端通信对象
            tftp = TftpServer(connfd)
            while True:
                #接受客户端的请求类型
                data = connfd.recv(BUFFERSIZE).decode()
                if data[0] == 'L':
                    tftp.do_list()
                elif data[0] == 'G':
                    tftp.do_get()
                elif data[0] == "P":
                    tftp.do_put()
                elif data[0] == "Q":
                    print("客户端退出")
                    sys.exit(0)
        else:
            connfd.close()
            continue

if __name__ == "__main__":
    main()
**********************************************************************************