multi_socket

threading_test.py

#threading
#为何在命令行能够执行,F5不能执行
#线程处理能致使同步问题
from socketserver import TCPServer,ThreadingMixIn,StreamRequestHandler
class Server(ThreadingMixIn,TCPServer):pass
class Handler(StreamRequestHandler):
    def handle(self):
        addr=self.request.getpeername()
        print('from',addr)
        self.wfile.write(b'thanks')
        print(self.rfile.read(1024).decode())
server=Server(('',1234),Handler)
server.serve_forever()

forking_test.py

#forking 分叉
##Windows 不支持分叉！！
''''分叉占据资源，而且若是有太多的客户端时分叉不能很好分叉（尽管如此，
对于合理数量的客户端，分叉在现代的UNIX或Linux系统中是很高效的，若是有一个多CPU系统那效率更高
）'''
from socketserver import TCPServer,ForkingMixIn,StreamRequestHandler
class Server(ForkingMixIn,TCPServer):pass
class Handler(StreamRequestHandler):
    def handle(self):
        addr=self.request.getpeername()
        print('from',addr)
        self.wfile.write(b'thanks')
server=Server(('',1234),Handler)
server.serve_forever()

select_test.py

#asynchronous I/O
'''
只处理在给定时间内真正要进行通讯的客户端。不须要一直监听，只要监听（或读取）一下子，
而后把它放到其余客户端的后面
这是asyncore/asynchat框架和Twisted框架采用的方法，这种功能的基础是select函数，
若是poll函数可用，那也能够是它，这两个函数都来自select模块。
这两个函数中，poll的伸缩性更好，但它只能在UNIX系统中使用

select须要3个序列做为它的必选参数，此外还有一个可选的以秒为单位的超时时间做为第4个参数
这些序列是文件描述符整数（或是带有返回这样整数的fileno方法的对象）。这些就是咱们等待的链接
3个序列用于输入，输出和异常状况（错误和相似的东西）
若是没有给定超时时间，select会阻塞（也就是处于等待状态），直到其中一个文件描述符已经为
行动作好了准备；若是给定了超时时间，select最多阻塞给定的超时时间，若是给定的超时时间是0，
那么就给出一个连续的poll(即不阻塞)。select的返回值是3个序列（也就是一个长度为3的元组），
没个表明相应参数的一个活动子集。好比，返回的第一个序列是一个输入文件描述符的序列，其中
有一些能够读取的东西
'''
import socket,select
s=socket.socket()
host=socket.gethostname()
port=1234
s.bind((host,port))
s.listen(5)
inputs=[s]
while True:
    rs,ws,es=select.select(inputs,[],[])
    for r in rs:
        if r is s:
            c,addr=s.accept()
            print('from',addr)
            inputs.append(c)
            #c.send(b'thank')
            for w in ws:
                if w:
                    w.send(b'thanks')
        else:
            try:
                data=r.recv(1024)
                disconnect=not data
            except socket.error:
                disconnect=True

            if disconnect:
                print(r.getpeername(),'disconnect')
                inputs.remove(r)
            else:
                print(data.decode())

poll_test.py

#poll_test
'''
在调用poll时，会获得一个poll对象。而后就可使用poll对象的register方法注册一个文件描述符（
或使用带有fileno方法的对象）。注册后能够unregister方法移除注册的对象
注册了一些对象（好比套接字）之后，就能够调用poll方法（带有一个可选的超时时间参数）并
获得一个(fd,event)格式列表（多是空的），其中fd是文件描述符，event告诉你发生了什么。
这是一个位掩码，意思是它是一个整数，这个整数的每一个位对应不一样的事件。
那些不一样的事件是select模块的常量。为了验证是否设置了一个给定位（也就是说，一个给定的事件
是否发生了），可使用按位与操做符：
if event & select.POLLIN:...
'''
import socket,select
s=socket.socket()
host=socket.gethostname()
port=1234
s.bind((host,port))

fdmap={s.fileno():s}

s.listen(5)
p=select.poll()
p.register(s)
while True:
    events=p.poll()
    for fd,event in events:
        if fd=s.fileno():
            c,addr=s.accept()
            print('from',addr)
            p.register(c)
            fdmap[c.fileno]=c
        elif event & select.POLLIN:
            data=fdmap[fd].recv(1024)
            if not data:
                print(fdmap[fd].getpeername(),'disconnect')
                p.unregister(fd)
                del fdmap[fd]
        else:
            print(data)

twisted_test.py

#twisted
'''
以前编写的基本套接字服务器是显示的。其中的一些有很清楚的事件循环，来查找新的链接和新数据，
而基于socketserver的服务器有一个隐式循环，在循环中服务器查找链接并为每一个链接建立一个处理程序，
但处理程序在要读数据时必须是显式的
Twisted使用一个事件甚至多个基于事件的方法。要编写基本的服务器，就要实现处理好比
新客户链接，新数据到达以及一个客户端断开链接等事件的事件处理程序

事件处理程序在一个协议(protocol)中定义，在一个新的链接到达时，一样须要一个建立这种协议对象
的工厂(factory)，但若是只是想要建立一个通用的协议类的实例，那么就可使用twisted自带的工厂
当编写本身的协议时，要使用和超类同样的模块中的protocol。获得了一个链接后，时间处理程序connectionMade
就会被调用。丢失了一个链接后，connectionLost就会被调用。来自客户端的数据是经过处理程序
dataReceived接收的。固然不能使用事件处理策略来把数据发回到客户端，若是要实现此功能，能够
使用对象self.transport的write方法，也有一个包含客户机地址的client属性
'''
from twisted.internet import reactor
from twisted.internet.protocol import Protocol,Factory
class SimpleLogger(Protocol):
    def connectionMade(self):
        print('from',self.transport.client)
        self.transport.write(b'thanks')
    def connectionLost(self,reason):
        print(self.transport.client,'disconnected')
    def dataReceived(self,data):
        print(data.decode())
factory=Factory()
factory.protocol=SimpleLogger
reactor.listenTCP(1234,factory)
reactor.run()

twisted_LineReceiver.py

#twisted LineReceiver协议
from twisted.internet import reactor
from twisted.internet.protocol import Factory
from twisted.protocols.basic import LineReceiver
class SimpleLogger(LineReceiver):
    def connectionMade(self):
        print('from',self.transport.client)
        #self.transport.write(b'thanks')
        self.sendLine(b'thanks2')
    def connectionLost(self,reason):
        print(self.transport.client,'disconnected')
    def lineReceived(self,line):
        #客户端发送的数据要加\r\n
        print(line.decode())
factory=Factory()
factory.protocol=SimpleLogger
reactor.listenTCP(1234,factory)
reactor.run()