#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 分叉

##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()

#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

'''

在调用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

'''

之前编写的基本套接字服务器是显示的。其中的一些有很清楚的事件循环，来查找新的连接和新数据，

而基于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协议

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()