2018-07-21tcp

udp通信模型中，在通信开始之前，不需要建立相关的链接，只需要发送数据即可

tcp通信模型中，在通信开始之前，一定要先建立相关的链接，才能发送数据，类似于生活中，"打电话""

---

总结：

tcp传输控制协议：稳定、相对于udp而言，要慢一些、web服务器都是使用的tcp

udp用户数据包协议：不稳定、适当比tcp要快一些。

想要完成一个tcp服务器的功能，需要的流程如下：

socket：创建一个套接字，默认是主动的套接字（相当于买个手机）

bind：绑定ip和port  （插上手机卡）

listen：使套接字变为可以被动链接  （设计手机为正常接听状态（即能够响铃））                  listen(5)代表：最多可以接受5个客户端的连接

accept：等待客户端的链接  （静静的等着别人拨打）

recv/send：接收发送数据

NAT模式下收发数据：

#coding =utf-8

from socket import *

tcpSerSocket = socket(AF_INET,SOCK_STREAM)

tcpSerSocket.bind(("",7788))

tcpSerSocket.listen(5)

newSocket,clientAddr=tcpSerSocket.accept()

recvData=newSocket.recv(1024)

print("接收到的数据是：%s"%recvData)

newSocket.send(b"xiexie!")

newSocket.close()

tcpSerSocket.close()

实现客户端收发功能：

#coding=utf-8

from socket import *

tcpCliSocket =socket(AF_INET,SOCK_STREAM)

serAddr=('192.168.20.125',7788)

tcpCliSocket.connect(serAddr)

sendData = raw_input("请输入要发送的数据")

tcoCliSocket.send(sendData)

recvData = tcpCliSocket.recv(1024)

print("接收到的数据是%s"%recvData)

tcpCliSocket.close()

注意：对于套接字，服务器端有两个，客户端有一个。

注意：参数类型是一个元组的。

运行的时候先启动服务器端，再运行脚本文件：

应用：模拟QQ聊天

客户端参考代码:

from socket import *

tcpCliSocket=socket(AF_INET,SOCK_STREAM)

serAddr = ("192.168.242.133",7788)

tcpCliSocket.connect(serAddr)

while True:

        sendData = input("send")

        if len(sendData)>0:

                tcpCliSocket.send(sendData.encode("gb2312"))

        else:

                break

        recvData = tcpCliSocket.recv(1024)

        print('recv:',recvData.decode("gb2312"))

tcpCliSocket.close()

服务端参考代码

from socket import *

tcpSerSocket=socket(AF_INET,SOCK_STREAM)

tcpSerSocket.bind("192.168.242.133",7788)

tcpSerSocket.listen(5)

while True:

        newSocket,seraddr=tcpSerSocket.accept()

        while True:

                recvdata =newSocket.recv(1024)

                if len(recvData)>0:

                        print("recv",recvData.decode("gb2312"))

                else:

                        break

            sendData = input("send:")

            newSocket.send(sendData.encode("gb2312"))

    newSocket.close()

tcpSerSocket.close()

listen参数问题

from socket import *

tcpSerSocket=socket(AF_INET,SOCK_STREAM)

tcpSerSocket.bind("192.168.242.133",7788)

tcpSerSocket.listen(int(input("请输入最大链接数')))

while True:

        newSocket,cliAddr=tcpSerSocket.accept()

        print(cliAddr)

        sleep(1)

客户端的代码：

from socket import *

for i in range(int(input("请输入最大的链接数")))

        s=socket(AF_INET,SOCK_STREAM)

        s.connect(("192.168.2420133",7788))

        print(i)

mac系统就是写几就是几，而linux系统它自己有最大值，你写的不管用，这就是为什么linux系统合适做web服务器开发。

在此期间，如果20个客户端调用了connect链接服务器，那么这个服务器的linux底层会自动维护2个队列（半链接和已链接）其中半链接和已链接的总数为listen中的值，如果这个值为5，那么意味着此时最多有5个客户端能够链接成功，而剩余的15个客户端阻塞在connect函数。

如果服务器调用了accept，那么linux底层中的那个半链接和已连接中的客户端的个数就少了一个，因此此时那15个因为connect堵塞的客户端又会在进行链接来争抢这一个空出来的位置。

---

多进程服务器

from socket import *

from multiprocessing import Process

from time import sleep

def dd(newSocket,destAddr)：

        while True:

                recvData = newSocket.recv(1024)

                if len(recvData)>0:

                        print("recv[%s]:%s"%(str(destAddr),recvData))

                else:

                        print("[%s]客户端已经关闭"%str(destAddr))

                        newSocker.close()

def main():

serSocket=socket(AF_INET,SOCK_STREAM)

serSocket.setSockopt(SOL_SOCKET,SO_REUSEADDR,1)

serSocket.bind(('192.168.242.133',7788))

serSocket.listen(5)

try:

        while True:

                print("---主进程，等待")

                newSocket,destAddr = serSocket.accept()

                print("主进程，创建进程")

                client = Process(target=dd,args=(newSocket,destAddr))

                client.start()

                newSocket.close()

finally:

        serSocket.close()

if __name__='__main__':

        main()

       默认情况下，两个独立的套接字不可与同一本地接口（在TCP/IP情况下，则是端口）绑定在一起。但是少数情况下，还是需要使用这种方式，来实现对一个地址的重复使用。设置了这个套接字，服务器便可在重新启动之后，在相同的本地接口以端口上进行监听。

        一般来说，一个端口释放后会等待两分钟之后才能再被使用，SO_REUSEADDR是让端口释放后立即就可以被再次使用。     SO_REUSEADDR用于对TCP套接字处于TIME_WAIT状态下的socket，允许重复绑定使用。server程序总是应该在调用bind()之前设置SO_REUSEADDR套接字选项。

通过为每个客户端创建一个进程的方式，能够同时为多个客户端进行服务，当客户端不是特别多的时候，这种方式还行，如果有几百上千个，就不可取了，因为每次创建进程等过程需要好较大的资源。

---

多线程服务器

from socket import *

from threading import Thread

from time import sleep

def dd(newSocket,destAddr)：

        while True:

                recvData = newSocket.recv(1024)

                if len(recvData)>0:

                        print("recv[%s]:%s"%(str(destAddr),recvData))

                else:

                        print("[%s]客户端已经关闭"%str(destAddr))

                        break

      newSocker.close()

def main():

serSocket=socket(AF_INET,SOCK_STREAM)

serSocket.setSockopt(SOL_SOCKET,SO_REUSEADDR,1)

serSocket.bind(('192.168.242.133',7788))

serSocket.listen(5)

try:

        while True:

                print("---主进程，等待")

                newSocket,destAddr = serSocket.accept()

                print("主进程，创建进程")

                client = Thread(target=dd,args=(newSocket,destAddr))

                client.start()

                newSocket.close()

finally:

        serSocket.close()

if __name__='__main__':

        main()

对于效率这一块，差不多的，但是进程耗费的资源要大，线程耗费的资源要小。不管是多进程还是多线程代码几乎一样，

区别在于：在多线程中newSocket.close()不能关闭，因为线程是共享同一份资源的，也就是共享全局变量的，传递东西也就是传递的引用，一个进程里面所有的线程都有共用同一份东西的。

如果serSocket不小心被close了，那么意味着：不能再接收新的客户端的链接了。

如果newSocket被close了，那么意味着：这个套接字就不能再使用recv和send来收发数据了。