首页 > > 网络编程 > 其它 >

网络并发编程总结

2018-09-18 06:45:16来源：博客园阅读 ()

网络编程

一.

1.网卡:

　　电脑中有网卡,网卡中有mac地址.

2.IP:

　　插上网线,路由器或交换机中的DHCP服务会自动分配IP地址.

　　IP:192.168.13.150

　　　　IPv4:　　

　　　　　　00000000.00000000.00000000.00000000

　　　　　　0-255　　0-255　　0-255　　0-255

　　　　IPv6:

　　　　　　00000000.00000000.00000000.00000000.00000000.00000000

3.子网掩码:255.255.255.0

　　IP:192.168.13.150

　　子网掩码:255.255.255.0

4.网关:路由器中连接交换机的口

　网关IP:第一个IP地址

5.DNS:

　　网络连接:

　　　　1.域名解析:

　　　　　　Windows电脑:先去本地的hosts文件中找IP

　　　　　　　　C:Windows\System32\drivers\etc\hosts

　　　　　　Linux/Mac电脑:

　　　　　　　　/etc/hosts

　　　　2.连接:

　　　　　　sk = socket.socket()

　　　　　　sk.connect(("127.0.0.1",8000))

　　　　3.如果创业:

　　　　　　1.租一个服务器+公网IP

　　　　　　2.租域名:域名+IP解析

总结:

　　IP:4个点分的十进制表示

　　DHCP:自动为局域网内中的电脑分配IP

　　网关:路由器中连接交换机的口

　　子网掩码:将挡住的IP位数作为网段,未挡住的部分作为可变的值

　　　　IP:192.168.13.15.

　　　　子网掩码:255.255.255.0

　　局域网,城域网,广域网

　　arp协议:通过目标的IP地址,查找目标的mac地址

　　DNS

二.

1.OSI模型:

　　7层模型:

　　　　应用层:使用软件

　　　　表示层:看到数据,如图片,视频

　　　　会话层:保持登录或链接状态

　　　　传输层:TCP/UDP

　　　　网络层:IP

　　　　数据链路层:MAC

　　　　物理层:将数据转换成电信号发送

　　5层模型:

　　　　应用层:应用层,表示层,会话层

　　　　传输层

　　　　网络层

　　　　数据链路层

　　　　物理层

　　4层:

　　　　应用层:应用层,表示层,会话层

　　　　传输层

　　　　网络层

　　　　物理层L数据链路层,物理层

2.三次握手四次挥手

#三次握手：
1.客户端(Client)向服务端(Server)发送一次请求
2.服务端确认并回复客户端
3.客户端检验确认请求，建立连接
#四次挥手：
1.客户端向服务端发一次请求
2.服务端回复客户端(断开客户端-->服务端)
3.服务端再次向客户端发请求(告诉客户端可以断开了)
4.客户端确认请求，连接断开

断开连接时,反映到代码上就是抛出异常或发送空内容

三.

1.BS(Browser/Server)和CS(Client/Server)架构

BS:浏览器/服务器

CS:客户端/服务器

　　a.CS架构是建立在局域网的基础上的,BS架构是建立在广域网的基础上的

　　b.CS一般比BS安全

　　c.CS更加注重流程,BS更加注重访问速度

　　d.BS比CS能更好的重用

　　e.CS比BS系统维护周期长,开销大

　　f.CS多是建立在Windiws平台上,BS建立在浏览器上.

四.

1.socket代码:

 1 import socket
 2 服务端:
 3 server = socket.socket()
 4 server.bind(("127.0.0.1",8000))
 5 server.listen(5)
 6 conn,addr = server.accept()
 7 
 8 客户端:
 9 client = socket.socket()
10 client.connect(("127.0.0.1",8000))

2.黏包:

　　1.发送数据时,每次发送的包小,因为系统进行优化算法,就将两次的包放在一起发送,减少了资源的重复占用,而客户端接收时,会一次全部接收

　　2.接收数据时,多次接收,第一次接收的数据量小,导致数据还没接收完,就停下了,剩下的数据会缓存在内存中,然后等到下次接收时和下一波数据一起接收.

解决方案:

　　1.先发送一个字节总大小,然后接收端循环接收所有数据.

　　2.使用time模块

　　3.先使用struct模块发送4个字节的文件大小,然后再发送数据.

3.协议:

　　自定义协议:{"code":1001,"data":{...}}

　　HTTP协议:GET /swd=alex HTTP/1.0\r\nhost:www.baidu.com\r\n\r\n

并发编程

1.线程,进程,协程的区别:

2.进程:

 1 import multiprocessing
 2 
 3 def task(arg):
 4     print(arg)
 5 
 6 def run():
 7     p = multiprocessing.Process(target=task,args=(1,))
 8     p.start()
 9 
10 if __name__ == '__main__':
11     run()

获取当前进程:name = multiprocessing.current_process()

进程间的数据共享:

 1 1.Queue
 2 
 3 import multiprocessing
 4 
 5 q = multiprocessing.Queue()
 6 
 7 def task(arg,q):
 8     q.put(arg)
 9 
10 def run():
11     for i in range(10):
12         p = multiprocessing.Process(target=task,args=(i,q))
13         p.start()
14 
15     while True:
16         v = q.get()
17         print(v)
18 
19 2.Manager
20 
21 import multiprocessing
22 
23 def task(arg,dic):
24     dic[arg] = 100
25 
26 if __name__ == '__main__':
27     m = multiprocessing.Manager()
28     dic = m.dict()
29     process_list = []
30     
31     for i in range(10):
32         p = multiprocessing.Process(target=taskargs=(i,dic))
33         p.start()
34         process_list.append(p)
35 
36     while True:
37         count = 0
38         for p in process_list:
39             if not p.is_alive():
40                 count += 1
41         if count == len(process_list):
42             break
43         print(dic)

进程锁:

 1 import time
 2 import multiprocessing
 3 
 4 lock = multiprocessing.RLock()
 5 
 6 def task(arg):
 7     print(111)
 8     lock.acquire()
 9     print(arg)
10     lock.release()
11 
12 if __name__ == '__main__':
13     p1 = multiprocessing.Process(target=task,args=(1,))
14     p1.start()
15 
16     p2 = multiprocessing.Process(target=task,args=(2,))
17     p2.start()

进程池

1 from concurrent.futures import ProcessPoolExcutor
2 
3 def task(arg):
4     print(arg)
5 
6 if __name__ == '__main__':
7     pool = ProcessPoolExcutor(5)
8     for i in range(10):
9         pool.submit(task,i)

3.线程

 1 import threading
 2 
 3 def task(arg):
 4     print(arg)
 5 
 6 for i in range(10):
 7     t = threading.Thread(target=task,args=(i,))
 8     t.start()
 9 
10 获取当前线程
11 ct = threading.current_thread()
12 
13 获取当前线程名字:
14 name = threading.getName()

线程锁:

 1 Lock:一次放一个,只能锁一次
 2 RLock:一次放一个,可以锁多次
 3 BoundedSemaphore(n):一次放n个
 4 Condition:一次放指定个
 5 Event:一次放所有
 6 
 7 import threading
 8 
 9 lock = threading.RLock()
10 
11 def task(arg):
12     lock.acquire()
13     print(arg)
14     lock.release()
15 
16 for i in range(10):
17     t = threading.Thread(target=task,args=(i,))
18     t.start()

线程池

1 from concurrent.futures import ThreadPoolExcutor
2 
3 def task(arg):
4     print(arg)
5 
6 pool = ThreadPoolExcutor(5)
7 for i in range(10):
8     pool.submit(task,i)

4.协程

 1 import greenlet
 2 
 3 def f1():
 4     print(111)
 5     g2.switch()
 6     print(222)
 7     g2.switch()
 8 
 9 def f2():
10     print(333)
11     g1.switch()
12     print(444)
13     g1.switch()
14 
15 g1 = greenlet.greenlet(f1)
16 g2 = greenlet.greenlet(f2)
17 g1.switch()

协程+IO

 1 from gevent import monkey
 2 monkey.patch_all()
 3 import requests
 4 import gevent
 5 
 6 def get_page1(url):
 7     ret = requests.get(url)
 8     print(ret.content)
 9 
10 def get_page2(url):
11     ret = requests.get(url)
12     print(ret.content)
13 
14 def get_page3(url):
15     ret = requests.get(url)
16     print(ret.content)
17 
18 gevent.joinall(
19     [
20     gevent.spwan(get_page1,'https://www.python.org/'),
21     gevent.spwan(get_page1,'https://www.yahoo.com/'),
22     gevent.spwan(get_page1,'https://github.com/'),
23 
24 
25 ]
26 
27 
28 )