码迷，mamicode.com
首页 > 数据库 > 详细

python 闯关之路四（下）（并发编程与数据库编程） 并发编程重点

时间：2018-08-11 12:28:45      阅读：213      评论：0      收藏：0      [点我收藏+]

标签：reading   bre   安装   生产者   mod   varchar   oca   无法   用户   

 

并发编程重点：

1
2
3
4
5
6
7
并发编程：线程、进程、队列、IO多路模型
 
操作系统工作原理介绍、线程、进程演化史、特点、区别、互斥锁、信号、
事件、join、GIL、进程间通信、管道、队列。
 
生产者消息者模型、异步模型、IO多路复用模型、select\poll\epoll 高性
能IO模型源码实例解析、高并发FTP server开发

1、请写一个包含10个线程的程序，主线程必须等待每一个子线程执行完成之后才结束执行，每一个子线程执行的时候都需要打印当前线程名、当前活跃线程数量；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from threading import Thread,currentThread,activeCount
import time
def task(n):
    print(‘线程名：%s----%s‘%(currentThread().name,n))
    time.sleep(1)
    print(‘数量：%s‘%activeCount())
     
if __name__ == "__main__":
    t_li = []
    for i in range(10):
        t = Thread(target=task,args=(i,))
        t.start()
        t_li.append(t)
    for t in t_li:
        t.join()
         
    print(‘主,end----‘)

2、请写一个包含10个线程的程序，并给每一个子线程都创建名为"name"的线程私有变量，变量值为“james”；

1
2
3
4
5
6
7
8
9
10
11
from threading import Thread
def task(name):
    print(‘%s is running‘%name)
    print(‘end ---‘)
     
if __name__ == "__main__":
    for i in range(10):
        t = Thread(target=task,args=(‘james_%s‘%i,))
        t.start()
         
    print(‘主 end ---‘)

3、请使用协程写一个消费者生产者模型；

协程知识点：https://www.cnblogs.com/wj-1314/p/9040121.html

协程：单线程下，无法利用多核，可以是一个程序开多个进程，每个进程开启多个线程，每隔线程开启协程；

　　协程指的是单个线程，因而一旦协程出现阻塞，将会阻塞整个线程。

1
2
3
4
5
6
7
8
9
10
11
12
13
def consumer():
    while True:
        x = yield
        print(‘消费:‘, x)
         
def producter():
    c = consumer()
    next(c)
    for i in range(10):
        print(‘生产:‘, i)
        c.send(i)
         
producter()

4、写一个程序，包含十个线程，子线程必须等待主线程sleep 10秒钟之后才执行，并打印当前时间；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
from threading import Thread,Event
import time
import datetime
def task():
    # while not event.is_set():
    #     print(‘...‘)
    print(‘...‘)
    event.wait(10)
    print(‘time:‘,datetime.datetime.now())
     
if __name__ == ‘__main__‘:
    event = Event()
    for i in range(10):
        t = Thread(target=task)
        t.start()
         
    time.sleep(10)
    event.set()

5、写一个程序，包含十个线程，同时只能有五个子线程并行执行；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
from threading import Thread,Semaphore,currentThread
import time
def task(n):
    sm.acquire()
    print(‘%s---‘%n,currentThread().name)
    time.sleep(1)
    print(‘end----‘)
    sm.release()
     
if __name__ == ‘__main__‘:
    sm = Semaphore(5)
    for i in range(10):
        t = Thread(target=task,args=(i,))
        t.start()

6、写一个程序 ，包含一个名为hello的函数，函数的功能是打印字符串“Hello, World!”，该函数必须在程序执行30秒之后才开始执行(不能使用time.sleep())；

1
2
3
4
5
6
7
from threading import Timer
def hello(name):
    print(‘%s say ‘%name,‘Hello World!‘)
     
if __name__ == "__main__":
    t = Timer(5,hello,args=(‘james‘,))
    t.start()

7、写一个程序，利用queue实现进程间通信；

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
from multiprocessing import Process,Queue,current_process
import time
def consumer(q):
    while True:
        res = q.get()
        if not res:break
        print(‘消费了：‘,res,‘--‘,current_process().name)
         
def producter(q):
    for i in range(5):
        print(‘生产:‘,i)
        time.sleep(1)
        q.put(i)
         
if __name__ == "__main__":
    q = Queue()
    p1 = Process(target=producter,args=(q,))
    c1 = Process(target=consumer,args=(q,))
    c2 = Process(target=consumer,args=(q,))
    p1.start()
    c1.start()
    c2.start()
   
    p1.join()
    q.put(None)
    q.put(None)
    print(‘主‘)
     
# JoinableQueue
from multiprocessing import Process,JoinableQueue,current_process
import time
def consumer(q):
    while True:
        res = q.get()
        print(‘消费了：‘,res,‘--‘,current_process().name)
        q.task_done()
         
def producter(q):
    for i in range(5):
        print(‘生产:‘,i,‘--‘,current_process().name)
        time.sleep(1)
        q.put(i)
    q.join()
     
if __name__ == "__main__":
    q = JoinableQueue()
    p1 = Process(target=producter,args=(q,))
    p2 = Process(target=producter, args=(q,))
    c1 = Process(target=consumer,args=(q,))
    c2 = Process(target=consumer,args=(q,))
    p1.start()
    p2.start()
     
    c1.daemon = True
    c2.daemon = True
    c1.start()
    c2.start()
     
    p1.join()
    p2.join()
    print(‘主‘)

8、写一个程序，利用pipe实现进程间通信；

1
2
3
4
5
6
7
8
9
10
11
from multiprocessing import Process,Pipe
def task(conn):
    conn.send(‘hello world‘)
    conn.close()
     
if __name__ == "__main__":
    parent_conn,child_conn = Pipe()
    p = Process(target=task,args=(child_conn,))
    p.start()
    p.join()
    print(parent_conn.recv())

9、使用selectors模块创建一个处理客户端消息的服务器程序；

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
# server  blocking IO 
import socket
server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
server.bind((‘127.0.0.1‘,8080))
server.listen(5)
while True:
    conn,addr = server.accept()
    print(addr)
    while True:
        try:
            data = conn.recv(1024)
            if not data: break
            conn.send(data.upper())
        except Exception as e:
            print(e)
            break
             
# server  IO多路复用 selectors 会根据操作系统选择select poll epoll          
import socket
import selectors
sel = selectors.DefaultSelector()
def accept(server_fileobj,mask):
    conn,addr = server_fileobj.accept()
    print(addr)
    sel.register(conn,selectors.EVENT_READ,read)
     
def read(conn,mask):
    try:
        data = conn.recv(1024)
        if not data:
            print(‘closing..‘,conn)
            sel.unregister(conn)
            conn.close()
            return
        conn.send(data.upper())
    except Exception:
        print(‘closeing...‘,conn)
        sel.unregister(conn)
        conn.close()
         
server_fileobj = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
server_fileobj.bind((‘127.0.0.1‘,8080))
server_fileobj.listen(5)
server_fileobj.setblocking(False)
sel.register(server_fileobj,selectors.EVENT_READ,accept)
while True:
    events = sel.select()
    for sel_obj,mask in events:
        callback = sel_obj.data
        callback(sel_obj.fileobj,mask)
         
# client
# -*- coding:utf-8 -*-
import socket
client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
client.connect((‘127.0.0.1‘,8080))
while True:
    msg = input(‘>>>:‘).strip()
    if not msg:continue
    client.send(msg.encode(‘utf-8‘))
    data = client.recv(1024)
    print(data.decode(‘utf-8‘))
 

10、使用socketserver创建服务器程序时，如果使用fork或者线程服务器，一个潜在的问题是，恶意的程序可能会发送大量的请求导致服务器崩溃，请写一个程序，避免此类问题；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# server socketserver 模块内部使用IO多路复用 和多进程/多线程
import socketserver
class Handler(socketserver.BaseRequestHandler):
    def handle(self):
        print(‘new 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()

11、请使用asyncio实现一个socket服务器端程序；

 12、写一个程序，使用socketserver模块，实现一个支持同时处理多个客户端请求的服务器，要求每次启动一个新线程处理客户端请求；

1
2
3
4
5
6
7
8
9
socketserver模块类介绍
      SocketServer内部使用 IO多路复用 以及 “多线程” 和 “多进程” ，
从而实现并发处理多个客户端请求的Socket服务端。即：每个客户端请求
连接到服务器时，Socket服务端都会在服务器是创建一个“线程”或者“进 程”
 专门负责处理当前客户端的所有请求。
        socketserver模块可以简化网络服务器的编写，python把网络服务抽
象成两个主要的类，一个是server类，用于处理连接相关的网络操作，另一个
是RequestHandler类，用于处理数据相关的操作。并且提供两个Mixln类，
用于扩展server，实现多进程或者多线程。

　　

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import socketserver
import threading
 
 
class MyServer(socketserver.BaseRequestHandler):
    def handle(self):
        while True:
            self.data = self.request.recv(1024).decode()
            print(self.data)
            self.request.send(self.data.upper().encode())
         
         
if __name__ == ‘__main__‘:
    server = socketserver.ThreadingTCPServer((‘127.0.0.1‘, 9999), MyServer)
    t = threading.Thread(target=server.serve_forever)
    t.start()

　　

数据库重点：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
1、数据库介绍、类型、特性
2、MySQL数据库安装、连接、启动、停止
3、表字段类型介绍、主键约束、表创建语句
4、常用增删改查语句、分组、聚合
5、外键管理、unique字段、表结构修改语法
6、跨表查询，inner join、left join、right join、full join语法
7、复杂SQL语句如group by、子查询、函数的使用
8、索引原理及作用、普通索引、多列索引、唯一索引、全文索引等
9、基于hash&b+树索引的实现原理，索引的优缺点剖析
10、事务原理，ACID特性，应用场景讲解
11、事务回滚
12、触发器的特性，应用场景
13、触发器的增删改查方法
14、存储过程的作用及应用场景
15、创建存储过程，参数传递，流程控制语句if\while\repeat\loop等，动态SQL的创建
16、视图的作用及使用场景，视图的增删改查
17、数据库权限管理，用户管理
18、数据库备份命令及工具讲解
19、基于不同业务的数据库表结构设计、性能优化案例
20、pymysql模块介绍和使用

修改表结构的语法

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
语法：
1. 修改表名
      ALTER TABLE 表名
                          RENAME 新表名;
 
2. 增加字段
      ALTER TABLE 表名
                          ADD 字段名  数据类型 [完整性约束条件…],
                          ADD 字段名  数据类型 [完整性约束条件…];
      ALTER TABLE 表名
                          ADD 字段名  数据类型 [完整性约束条件…]  FIRST;
      ALTER TABLE 表名
                          ADD 字段名  数据类型 [完整性约束条件…]  AFTER 字段名;
 
3. 删除字段
      ALTER TABLE 表名
                          DROP 字段名;
 
4. 修改字段
      ALTER TABLE 表名
                          MODIFY  字段名 数据类型 [完整性约束条件…];
      ALTER TABLE 表名
                          CHANGE 旧字段名 新字段名 旧数据类型 [完整性约束条件…];
      ALTER TABLE 表名
                          CHANGE 旧字段名 新字段名 新数据类型 [完整性约束条件…];

　　

1、创建一个表student，包含ID(学生学号)，sname(学生姓名)，gender(性别)，credit(信用卡号),四个字段，要求：ID是主键，且值自动递增，sname是可变长字符类型，gender是枚举类型, credit是可变长字符类型；

1
2
3
4
5
6
create table student(
    ID int primary key auto_increment,
    sname varchar(16) not null,
    gender enum(‘male‘,‘female‘) not null default ‘female‘,
    credit varchar(32)
);

　　

2、在上面的student表中增加一个名为class_id的外键，外键引用class表的cid字段；

1
2
3
4
5
6
7
create table class(
    cid int primary key auto_increment,
    cname varchar(16) not null
);
   
alter table student add class_id int not null;
alter table student add foreign key(class_id) references class(cid) on delete cascade on update cascade;

 

3、向该表新增一条数据，ID为1，学生姓名为alex，性别女，修改ID为1的学生姓名为wupeiqi，删除该数据；

1
2
3
4
5
6
insert into class(cname) values
(‘一班‘),
(‘二班‘);
insert into student values(1,‘alex‘,‘female‘,‘12345‘,1);
update student set sname = ‘wupeiqi‘ where id = 1;
delete from student where id = 1;

　　

4、查询student表中，每个班级的学生数；

1
2
3
4
5
insert into student(sname,class_id) values
(‘james‘,1),
(‘durant‘,2),
(‘curry‘,3);
select count(ID) from student;

　　

5、修改credit字段为unique属性；

1
alter table student modify credit varchar(32) not null unique;

　　

6、请使用命令在你本地数据库中增加一个用户，并给该用户授予创建表的权限；

1
grant create on *.* to ‘james‘@‘localhost‘ identified by ‘123‘;      

　　

7、请使用pymsql模块连接你本地数据库，并向student表中插入一条数据；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# _*_ coding: utf-8 _*_
# 7、请使用pymsql模块连接你本地数据库，并向student表中插入一条数据；
import pymysql
conn = pymysql.connect(
    host = ‘127.0.0.1‘,
    port = 3306,
    user = ‘root‘,
    password = ‘******‘,
    db = ‘test622‘,
    charset = ‘utf8‘
)
cursor = conn.cursor()
sql = "insert into student values(13,‘park‘,‘男‘,‘123456‘,1)"
rows = cursor.execute(sql)
 
conn.commit()
cursor.close()
conn.close()

　　

8、请使用mysqldump命令备份student表；

1
mysqldump -uroot -p123 db_bj student > /home/bj/桌面/myfile/student.sql

　　

9、创建一张名为student_insert_log的表，要求每次插入一条新数据到student表时，都向student_insert_log表中插入一条记录，记录student_id, insert_time;

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
mysql> desc student;
+----------+-----------------------+------+-----+---------+----------------+
| Field    | Type                  | Null | Key | Default | Extra          |
+----------+-----------------------+------+-----+---------+----------------+
| ID       | int(11)               | NO   | PRI | NULL    | auto_increment |
| sname    | varchar(16)           | NO   |     | NULL    |                |
| gender   | enum(‘male‘,‘female‘) | NO   |     | female  |                |
| credit   | varchar(32)           | NO   | UNI | NULL    |                |
| class_id | int(11)               | NO   | MUL | NULL    |                |
+----------+-----------------------+------+-----+---------+----------------+
   
create table student_insert_log(
    student_id int not null,
    insert_time datetime not null
);
     
创建一个触发器：
delimiter //
create trigger tri_after_insert_student after insert on student for each row
begin
    insert into student_insert_log values(new.ID,now());
end //
delimiter ;
     
insert into student(sname,credit,class_id) values (‘alice‘,‘123‘,2);
insert into student(sname,credit,class_id) values
(‘egon1‘,‘1234‘,1),
(‘egon2‘,‘12345‘,2);
     
mysql> select * from student;
+----+-------+--------+---------+----------+
| ID | sname | gender | credit  | class_id |
+----+-------+--------+---------+----------+
|  4 | alcie | female | 123456  |        1 |
|  7 | alcie | female | 1234567 |        1 |
|  8 | alice | female | 123     |        2 |
|  9 | egon1 | female | 1234    |        1 |
| 10 | egon2 | female | 12345   |        2 |
+----+-------+--------+---------+----------+
     
mysql> select * from student_insert_log;
+------------+---------------------+
| student_id | insert_time         |
+------------+---------------------+
|          8 | 2018-04-24 21:29:46 |
|          9 | 2018-04-24 21:32:05 |
|         10 | 2018-04-24 21:32:05 |
+------------+---------------------+
10、创建一张名为student_update_log的表，要求每次更新student表中的记录时，都向student_update_log表中插入一条记录，记录student_id, update_time;
create table student_update_log(
    student_id int not null,
    update_time datetime
); 
     
创建一个触发器
delimiter //
create trigger tri_after_update_student after update on student for each row
begin
    insert into student_update_log values(new.ID,now());
end //
delimiter ;
     
show triggers\G;
     
update student set sname = ‘alex‘ where ID in (9,10);
mysql> select * from student;
+----+-------+--------+---------+----------+
| ID | sname | gender | credit  | class_id |
+----+-------+--------+---------+----------+
|  4 | alcie | female | 123456  |        1 |
|  7 | alcie | female | 1234567 |        1 |
|  8 | alice | female | 123     |        2 |
|  9 | alex  | female | 1234    |        1 |
| 10 | alex  | female | 12345   |        2 |
+----+-------+--------+---------+----------+
5 rows in set (0.00 sec)
     
mysql> select * from student_update_log;
+------------+---------------------+
| student_id | update_time         |
+------------+---------------------+
|          9 | 2018-04-24 21:47:24 |
|         10 | 2018-04-24 21:47:24 |
+------------+---------------------+

python 闯关之路四（下）（并发编程与数据库编程） 并发编程重点

标签：reading   bre   安装   生产者   mod   varchar   oca   无法   用户   

原文地址：https://www.cnblogs.com/anzhangjun/p/9459131.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！