练习题
基于queue模块实现线程池
import threading from multiprocessing import Queue class A(threading.Thread): def __init__(self,queue): threading.Thread.__init__(self) self.data = queue def run(self): for i in range(100): self.data.put(i) class B(threading.Thread): def __init__(self,queue): threading.Thread.__init__(self) self.data = queue def run(self): while True: try: val = self.data.get(True,10) print(val) except Exception as e: print( "Get data timeout!") break def main(): q = Queue() a = A(q) b = B(q) a.start() b.start() a.join() b.join() if __name__ == "__main__": main() print ("test program end.")
1、基于多线程实现并发的套接字通信
客户端
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
# _*_ coding: utf-8 _*_ from socket import *
ip_port = ('127.0.0.1',9999)
client = socket(AF_INET,SOCK_STREAM)
client.connect(ip_port)while True:
cmd = input(">>>").strip()
if not cmd:
continue
client.send(cmd.encode('utf-8'))
data = client.recv(1024)
print(data.decode('utf-8'))
client.close() |
服务端
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
import multiprocessing
import threading
import socket
ip_port = ('127.0.0.1',9999)
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.bind(ip_port)s.listen(5)
def action(conn):
while True:
data = conn.recv(1024)
print(data)
conn.send(data.upper())
if __name__ == '__main__':
while True:
conn,addr = s.accept()
p = threading.Thread(target=action,args=(conn,))
p.start()
|
2、编写一个简单的文本处理工具，具备三个任务，一个接收用户输入，一个将用户输入的内容格式化成大写，一个将格式化后的结果存入文件
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
# _*_ coding: utf-8 _*_ # 练习二：三个任务，一个接收用户输入，一个将用户输入的内容格式# 化成大写，一个将格式化后的结果存入文件from threading import Thread
msg_l = []
format_l = []
def talk():
while True:
msg = input(">>>").strip()
if not msg:
break
msg_l.append(msg)
def format_msg():
while True:
if msg_l:
res = msg_l.pop()
format_l.append(res.upper())
def save():
while True:
if format_l:
with open('db.txt','a',encoding='utf-8') as f:
res = format_l.pop()
f.write('%s\n'%res)
if __name__ == '__main__':
t1 = Thread(target=talk)
t2 = Thread(target=format_msg)
t3 = Thread(target=save)
t1.start()
t2.start()
t3.start()
|
1、简述计算机操作系统中的“中断”的作用？
中断是指在计算机执行期间，系统内发生任何非寻常的或非预期的急需处理事件，使得CPU暂时中断当前正在执行的程序而转去执行相应的时间处理程序。
待处理完毕后又返回原来被中断处继续执行或调度新的进程执行的过程。 当遇到IO操作时或一个进程运行时间过长或被更高的优先级的进程替代时出现中断。有利于合理利用有限的系统资源，提高程序运行效率。
2、简述计算机内存中的“内核态”和“用户态”；
处于用户态的程序只能访问用户空间，而处于内核态的程序可以访问用户空间和内核空间。 当一个任务（进程）执行系统调用而陷入内核代码中执行时，我们就称进程处于内核运行态（或简称为内核态）。此时处理器处于特权级最高的（0级）内核代码中执行。当进程处于内核态时，执行的内核代码会使用当前进程的内核栈。每个进程都有自己的内核栈。 当进程在执行用户自己的代码时，则称其处于用户运行态（用户态）。此时处理器在特权级最低的（3级）用户代码中运行。 用户态切换到内核态的3种方式： 1、系统调用：这是用户态进程主动要求切换到内核态的一种方式 2、异常 3、外围设备的中断
3、进程间通信方式有哪些？
进程间通信（IPC）方式主要包括以下几种:
（1）管道，分为有名管道和无名管道，是一种半双工的通信方式。
（2）信号量，信号量是一个计数器,可以用来控制多个线程对共享资源的访问。
（3）信号，信号是一种比较复杂的通信方式,用于通知接收进程某个事件已经发生。
（4）消息队列，息队列是消息的链表,存放在内核中并由消息队列标识符标识。
（5）共享内存，共享内存就是映射一段能被其他进程所访问的内存,这段共享内存由一个进程创建,但多个进程都可以访问.共享内存是最快的IPC(进程间通信)方式。
（6）套接字：可用于不同及其间的进程通信。
4、简述你对管道、队列的理解；
管道：通常指无名管道 它是半双工的（即数据只能在一个方向上流动），具有固定的读端和写端。 它只能用于具有亲缘关系的进程之间的通信（也是父子进程或者兄弟进程之间）。 它可以看成是一种特殊的文件，对于它的读写也可以使用普通的read、write 等函数。但是它不是普通的文件，并不属于其他任何文件系统，并且只存在于内存中。 队列：是消息的链接表。一个消息队列由一个标识符（即队列ID）来标识。 消息队列是面向记录的，其中的消息具有特定的格式以及特定的优先级。 消息队列独立于发送与接收进程。进程终止时，消息队列及其内容并不会被删除。 消息队列可以实现消息的随机查询,消息不一定要以先进先出的次序读取,也可以按消息的类型读取。 队列和管道都是将数据存放于内存中，而队列是基于“管道+锁”实现的。
5、请列举你知道的进程间通信方式；
1.管道（无名管道）：速度慢，容量有限，只有父子进程能通讯。它不是普通的文件，并不属于其他任何文件系统，并且只存在于内存中。它是半双工的（即数据只能在一个方向上流动），具有固定的读端和写端。 2.FIFO（命名管道）：任何进程间都能通讯，但速度慢，它是一种文件类型。 3.消息队列：是消息的链接表，存放在内核中。消息队列独立于发送与接收进程。进程终止时，消息队列及其内容并不会被删除，所以要注意第一次读的时候，要考虑上一次没有读完数据的问题。容量受到系统限制。消息队列可以实现消息的随机查询 4.信号量：信号量用于实现进程间的互斥与同步，而不是用于存储进程间通信数据。 5.共享内存区：能够很容易控制容量，速度快，但要保持同步，比如一个进程在写的时候，另一个进程要注意读写的问题，相当于线程中的线程安全，当然，共享内存区同样可以用作线程间通讯，不过没这个必要，线程间本来就已经共享了同一进程内的一块内存 信号量+共享内存通常结合在一起使用，信号量用来同步对共享内存的访问。
6、什么是同步I/O，什么是异步I/O？
同步IO：当程序发生IO操作时，会将进程阻塞，直到IO操作完成才能继续执行后面的代码。
同步I/O，用户进程需要主动读写数据。
异步I/O，不需要主动读写数据，只需要读写数据完成的通知。异步IO：进程不会发生阻塞。
总结：
阻塞/非阻塞是内核级的，同步/异步是进程级的，同步非阻塞和异步阻塞一般不会采用，异步非阻塞一般效率比较高，他能够把cpu和io并行处理，当然，如果没有cpu和io并行的这种情况，那就用同步阻塞比较好，这样编程比较简单，且不用多次在内核空间和用户空间进行切换
7、请问multiprocessing模块中的Value、Array类的作用是什么？举例说明它们的使用场景
使用Value或者Array把数据存储在一个共享的内存表中，用于实现进程间共享状态。 Value( typecode, arg1, … argN, lock ) 在共享内容中常见ctypes对象。typecode要么是包含array模块使用的相同类型代码（如’i’,’d’等）的字符串，要么是来自ctypes模块的类型对象（如ctypes.c_int、ctypes.c_double等）。 所有额外的位置参数arg1, arg2 ….. argN将传递给指定类型的构造函数。lock是只能使用关键字调用的参数，如果把它置为True（默认值），将创建一个新的锁定来包含对值的访问。 如果传入一个现有锁定，比如Lock或RLock实例，该锁定将用于进行同步。如果v是Value创建的共享值的实例，便可使用v.value访问底层的值。例如，读取v.value将获取值，而赋值v.value将修改值。 RawValue( typecode, arg1, … ,argN) 同Value对象，但不存在锁定。 Array( typecode, initializer, lock ) 在共享内存中创建ctypes数组。typecode描述了数组的内容，意义与Value()函数中的相同。initializer要么是设置数组初始大小的整数，要么是项目序列，其值和大小用于初始化数组。lock是只能使用关键字调用的参数，意义与Value()函数中相同。 如果a是Array创建的共享数组的实例，便可使用标准的python索引、切片和迭代操作访问它的内容，其中每种操作均由锁定进行同步。对于字节字符串，a还具有a.value属性，可以吧整个数组当做一个字符串进行访问。 RawArray(typecode, initializer ) 同Array对象，但不存在锁定。当所编写的程序必须一次性操作大量的数组项时，如果同时使用这种数据类型和用于同步的单独锁定（如果需要的话），性能将得到极大的提升。
# 进程间共享状态,当然尽最大可能防止使用共享状态，但最终有可能会使用到.
# 1-共享内存
# 可以通过使用Value或者Array把数据存储在一个共享的内存表中
from multiprocessing import Process,Value,Array
import time
def f(n, a, name):
time.sleep(1)
n.value = name * name
for i in range(len(a)):
a[i] = -i
process_list = []
if __name__ == '__main__':
num = Value('d',0.0) # d表示一个双精浮点类型
arr = Array('i',range(10)) # i表示一个带符号的整型
for i in range(10):
p = Process(target=f,args=(num, arr, i))
p.start()
process_list.append(p)
for j in process_list:
j.join()
print(num.value)
print(arr[:])
# 更加灵活的共享内存可以使用multiprocessing.sharectypes模块
https://blog.csdn.net/winterto1990/article/details/48106505
8、请问multiprocessing模块中的Manager类的作用是什么？与Value和Array类相比，Manager的优缺点是什么？
使用Value或者Array把数据存储在一个共享的内存表中。 Manager()返回一个manager类型，控制一个server process，可以允许其它进程通过代理复制一些python objects。 支持：list,dict,Namespace,Lock,Semaphore,BoundedSemaphore,Condition,Event,Queue,value,Array ； Manager 提供了多进程环境中共享数据的使用的方案, 共享数据可以支持跨进程, 甚至跨机器访问, 以网络通信的方式实现(eg: unix socket, tpc),一个 manager 实例控制一个 server 进程(manager 自己创建的后台进程,对用户透明), 该 server 负责管理共享数据. 其他进程则是用户业务创建的,它们可以通过代理方式来访问 manager 自带 server 的共享数据. 代理可以理解为一个网络通道, 业务进程 和 manager server 进程通信交互数据, 由于server 单线程, 对业务进程通信请求FIFO的方式来处理数据, 因此保证了操作行为的可预期性(当然如果业务进程希望锁定数据, 可以通过代理的 Lock 锁机制来实现). manger的的优点是可以在poor进程池中使用，缺点是windows下环境下性能比较差，因为windows平台需要把Manager.list放在if name='main'下，而在实例化子进程时，必须把Manager对象传递给子进程，否则lists无法被共享，而这个过程会消耗巨大资源，因此性能很差。
https://www.cnblogs.com/shengyang17/p/8987075.html
9、写一个程序，包含十个线程，子线程必须等待主线程sleep 10秒钟之后才执行，并打印当前时间；
import time
from threading import Thread, currentThread
def task():
print("current time:", time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
if __name__ == "__main__":
t_l = []
for i in range(10): # 开启10个线程
t = Thread(target=task)
t_l.append(t)
for t in t_l:
time.sleep(10)
t.start()
from threading import Thread,currentThread,Event
import time
event = Event()
def task():
event.wait()
print("name:%s time:%s"%(currentThread().getName(),time.strftime('%Y-%m-%d %H:%M:%S',time.localtime())))
if __name__ == '__main__':
for i in range(10):
t = Thread(target=task)
t.start()
time.sleep(10)
event.set()
10、写一个程序，包含十个线程，同时只能有五个子线程并行执行；
import time
import random
from threading import Thread, currentThread, Semaphore
def task():
sm.acquire()
print("%s is running" % currentThread().getName())
time.sleep(random.randint(1, 3))
sm.release()
if __name__ == "__main__":
sm = Semaphore(5)
for i in range(10):
t = Thread(target=task, name="线程%s" % i)
t.start()
11、写一个程序，要求用户输入用户名和密码，要求密码长度不少于6个字符，且必须以字母开头，如果密码合法，则将该密码使用md5算法加密后的十六进制概要值存入名为password.txt的文件，超过三次不合法则退出程序；
import re, hashlib,json
def func():
count =0
while count <3:
username = input('username:').strip()
password= input("password:").strip()
if len(password)>=6 and re.search("\A[a-zA-Z]",password):
obj = {'username':username,'password':hashlib.md5(password.encode('utf-8')).hexdigest()}
json.dump(obj,open('password.txt','a',encoding='utf-8'))
print('注册成功')
break
else:
print('密码长度不少于6个字符，且必须以字母开头')
count += 1
if __name__ == '__main__':
func()
class Client:
"""客户端"""
def __init__(self, ip, port):
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sock.connect((ip, port))
def handle_msg(self):
"""发送、接收消息"""
while True:
msg = input(">>>").strip()
if not msg:
break
self.sock.send(msg.encode())
data = self.sock.recv(1024)
print("from server:", data.decode())
if __name__ == "__main__":
client = Client("127.0.0.1", 8080)
print("server connecting.....")
client.handle_msg()