day41 Pyhton 并发编程04

内容回顾

　　socket

　　　　最底层的网络通信

　　　　所有的网络通信都是基于socket

　进程

　　　　什么是进程?

　　　　是操作系统的发展过程中,为了提高cpu的利用率,在操作系统同时运行多个程序的时候,为了数据的安全\代码不混乱而创造的一个概念

　　　　每一个程序运行起来都至少是一个进程

　　　　进程是计算机中最小的资源分配单位

　　　　进程被操作系统调度的,有很多相关的算法--早期的操作系统

　　　　进程之间是数据隔离的

　　　　进程的三状态就绪运行阻塞

　　　　同步异步

　　　　　　同步:一个任务的执行依赖另一个事务的结束

　　　　　　　　join lock

　　　　　　异步:一个任务的执行不依赖另一个事务的结束

　　　　　　　　start terminate

　　　　阻塞非租塞

　　　　　　阻塞 :accept recv recvfrom queue.get join

　　　　　　非租塞: setblocking = False

　　　　并发并行

　　　　　　并行是特殊的并发

　　　　　　并行就是同一时刻两个以上的程序同时在cpu上执行

　　　　　　并发就是同一时段两个以上的程序看起来在同时执行

　　　　IO概念: 文件操作数据库操作网络传输用户输入输出

　　　　　　　Input 得到bytes/str

　　　　　　 Output 发送数据/输出数据

因为进程与进程之间本质上是异步且数据隔离

守护进程:子进程等待主进程的代码结束就结束了

同步控制

　　　　join

　　　　锁 -互斥锁: 多个进程同时对一个数据进行操作的时候,操作同一个文件/数据库/管道/Manager.dict

　　　　信号量

　　　　事件

数据共享 - 数据不安全

　　　　Manager

IPC-进程之间通信

　　　　管道

　　　　队列 - 生产者消费者模型(为了解决数据的生产和处理的效率问题)

　　　　第三方工具(消息队列,消息中间件)

进程池

　　　　解决大量任务开启多个进程的开销过大的问题

　　　　节省资源,提高并发效率的

　　　　一般开进程数 cpu_count *1 or 2

今日内容

初识进程

为什么要有线程

线程在操作系统中有什么特点

线程在python语言中有什么特点

GIL全局解释器锁

　　为什么要有全局解释器锁

在python中如何开启线程

线程的基础的使用

线程的概念

# 多进程 socket server

# 只要来了一个client请求 开一个进程

# 进程开多了就会卡

    # 进程的调度

    # 进程的开启的开销

    # 给操作系统的负担

# 数据\文件\代码

# 记录当前的执行位置

# 假设有一个机制

    # 开启进程的开销变短

    # 调度的时间也变短

    # 操作系统减负

# 线程是计算机中被CPU调度的最小单位

# 线程 : 轻量级的进程/轻型进程

# 线程本身创建出来就是为了解决并发问题的

# 并且它的整体效率比进程要高

# 但是线程实际上也有一些性能上的限制\管理调度开销

# 在整个程序界:

    # 如果你的程序需要数据隔离 : 多进程

    # 如果你的程序对并发的要求非常高 : 多线程

# socketserver 多线程的

# web的框架 django flask tornado 多线程来接收用户并发的请求

# 线程

    # 轻量级

    # 在进程中数据共享

    # 是进程的一部分,不能独立存在的

    # 计算机中能被CPU调度的最小单位

# 进程

    # 对操作系统的压力大

    # 数据隔离

    # 可以在操作系统中独立存在

    # 计算机中资源分配的最小单位

# 在整个编程界

# 同一个进程中的多个线程能不能同时使用多个cpu

# python

# 单核的 一个cpu

# 多核的 作为一门脚本语言

# 线程锁这件事儿是有Cpython解释器完成

# 对于python来说 同一时刻只能有一个线程被cpu访问

# 彻底的解决了多核环境下的安全问题

# 线程锁 : 全局解释器锁 GIL

    # 1.这个锁是锁线程的

    # 2.这个锁是解释器提供的

# 多线程仍然有它的优势

    # 你的程序中用到cpu真的多么

    # 如果100% 90%的时间都消耗在计算上,那么cpython解释器下的多线程对你来说确实没用

    # 但是你写的大部分程序 的时间实际上都消耗在了IO操作上

# 遇到高计算型

    # 开进程 4个进程  每个进程里开n个线程

    # 换个解释器

threading模块

import os

import time

from threading import Thread

# Process 进程类

# Thread  线程类

# 1.初识线程模块

def func():

    print('start',os.getpid())

    time.sleep(1)

    print('end')

if __name__ == '__main__':

    t = Thread(target=func)

    t.start()

    for i in range(5):

        print('主线程',os.getpid())

        time.sleep(0.3)

import time

from threading import Thread

def func():

    n = 1 + 2 + 3

    n ** 2

if __name__ == '__main__':

    start = time.time()

    lst = []

    for i in range(100):

        t = Thread(target=func)

        t.start()

        lst.append(t)

    for t in lst:

        t.join()

    print(time.time() - start)#0.026000261306762695

# import time

# from multiprocessing import Process as Thread

# def func():

#     n = 1 + 2 + 3

#     n**2

#

# if __name__ == '__main__':

#     start = time.time()

#     lst = []

#     for i in range(100):

#         t = Thread(target=func)

#         t.start()

#         lst.append(t)

#     for t in lst:

#         t.join()

#     print(time.time() - start)#15.187999963760376

# 3.线程的数据共享

from threading import Thread

n = 100

def func():

    global n

    n -= 1

t = Thread(target=func)

t.start()

t.join()

print(n)

# 4.开启线程的另一种方式

from threading import Thread

class Mythread(Thread):

    def __init__(self,arg):

        super().__init__()

        self.arg = arg

    def run(self):

        print('in son',self.arg)

t = Mythread(123)

t.start()

# 5.threading模块中的其他功能

import time

from threading import Thread,currentThread,activeCount,enumerate

class Mythread(Thread):

    def __init__(self,arg):

        super().__init__()

        self.arg = arg

    def run(self):

        time.sleep(1)

        print('in son',self.arg,currentThread())

for i in range(10):

    t = Mythread(123)

    t.start()

    print(t.ident)

print(activeCount())

print(enumerate())

守护线程

import time

from threading import Thread

def func():

    while True:

        print('in func')

        time.sleep(0.5)

def func2():

    print('start func2')

    time.sleep(10)

    print('end func2')

Thread(target=func2).start()

t = Thread(target=func)

t.setDaemon(True)

t.start()

print('主线程')

time.sleep(2)

print('主线程结束')

守护进程 只守护主进程的代码,主进程代码结束了就结束守护,守护进程在主进程之前结束 
守护线程 随着主线程的结束才结束,守护线程是怎么结束的   
进程 terminate 强制结束一个进程的 
线程 没有强制结束的方法 
线程结束 : 线程内部的代码执行完毕 那么就自动结束了
多线程实现socket_server

server

import socket

from threading import Thread

def talk(conn):

    while True:

        msg = conn.recv(1024).decode()

        conn.send(msg.upper().encode())

sk = socket.socket()

sk.bind(('127.0.0.1',9000))

sk.listen()

while True:

    conn,addr = sk.accept()

    Thread(target=talk,args = (conn,)).start()

import socket

sk = socket.socket()

sk.connect(('127.0.0.1',9000))

while True:

    sk.send(b'hello')

    print(sk.recv(1024))

巴特西

day41 Pyhton 并发编程04

最新文章

热门文章