练习题|并发编程

　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对象，但不存在锁定。当所编写的程序必须一次性操作大量的数组项时，如果同时使用这种数据类型和用于同步的单独锁定（如果需要的话），性能将得到极大的提升。 

from threading import Thread
import time

def task(name):
    print(name, time.strftime(‘%Y-%m-%d %H:%M:%S‘,time.localtime()))

if __name__ == ‘__main__‘:
    time.sleep(10)
    for i in range(10):
        t = Thread(target=task, args=(‘线程 %s‘%i, ))
        t.start()

打印：
线程 0 2018-04-24 13:37:38
线程 1 2018-04-24 13:37:38
线程 2 2018-04-24 13:37:38
线程 3 2018-04-24 13:37:38
线程 4 2018-04-24 13:37:38
线程 5 2018-04-24 13:37:38
线程 6 2018-04-24 13:37:38
线程 7 2018-04-24 13:37:38
线程 8 2018-04-24 13:37:38
线程 9 2018-04-24 13:37:38

from threading import Thread, Semaphore, currentThread
import time
sem = Semaphore(5)
def task():
    with sem:
        print(‘%s in‘%currentThread().getName())
        time.sleep(2)
if __name__ == ‘__main__‘:
    for i in range(10):
        t = Thread(target=task,  )
        t.start()

打印：一开始只有5个子进程并行执行
Thread-1 in
Thread-2 in
Thread-3 in
Thread-4 in
Thread-5 in

Thread-6 in
Thread-8 in
Thread-7 in
Thread-9 in
Thread-10 in

from concurrent.futures import ThreadPoolExecutor
from threading import currentThread
import os,time
def task():
    print(‘name:%s in pid:%s‘%(currentThread().getName(), os.getpid()))
    time.sleep(2)
if __name__ == ‘__main__‘:
    pool = ThreadPoolExecutor(5)
    for i in range(10):
        pool.submit(task, )
    pool.shutdown(wait=True)

打印：
name:<concurrent.futures.thread.ThreadPoolExecutor object at 0x0000000001E8FCF8>_0 in pid:9152
name:<concurrent.futures.thread.ThreadPoolExecutor object at 0x0000000001E8FCF8>_1 in pid:9152
name:<concurrent.futures.thread.ThreadPoolExecutor object at 0x0000000001E8FCF8>_2 in pid:9152
name:<concurrent.futures.thread.ThreadPoolExecutor object at 0x0000000001E8FCF8>_3 in pid:9152
name:<concurrent.futures.thread.ThreadPoolExecutor object at 0x0000000001E8FCF8>_4 in pid:9152


name:<concurrent.futures.thread.ThreadPoolExecutor object at 0x0000000001E8FCF8>_1 in pid:9152
name:<concurrent.futures.thread.ThreadPoolExecutor object at 0x0000000001E8FCF8>_0 in pid:9152
name:<concurrent.futures.thread.ThreadPoolExecutor object at 0x0000000001E8FCF8>_2 in pid:9152
name:<concurrent.futures.thread.ThreadPoolExecutor object at 0x0000000001E8FCF8>_3 in pid:9152
name:<concurrent.futures.thread.ThreadPoolExecutor object at 0x0000000001E8FCF8>_4 in pid:9152

import re, hashlib, json
def func():
    count = 0
    while count < 3:
        usename = input(‘usename:‘)
        password = input(‘password:‘)
        if len(password) <6 or not re.search(‘\A([a-z]|[A-Z])‘, password):
            count += 1
        else:
            obj = {‘usename‘:usename, ‘password‘:hashlib.md5(password.encode(‘utf-8‘)).hexdigest()}
            json.dump(obj, open(‘password.txt‘, ‘a‘, encoding=‘utf-8‘))
            break
if __name__ == ‘__main__‘:
    func()

##服务端
import socketserver
class Handler(socketserver.BaseRequestHandler):
    def handle(self):
        print(‘connection:‘, self.client_address)
        while True:
            try:
                data = self.request.recv(1024)
                if not data:break
                print(‘client data:‘, data.decode())
                self.request.send(data.upper())
            except Exception as e:
                print(e)
                break
if __name__ == ‘__main__‘:
    server = socketserver.ThreadingTCPServer((‘127.0.0.1‘, 8080), Handler)
    server.serve_forever()

##客户端
import socket
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect((‘127.0.0.1‘, 8080))
while True:
    msg = input(‘>>>:‘)
    if not msg:break
    client.send(msg.encode(‘utf-8‘))
    data = client.recv(1024)
    print(data.decode(‘utf-8‘))