进程与线程

参考学习方法:
    1.通读博客
    2.看笔记,照着上课的代码重新敲一遍
    3.在敲代码的过程中再确认一下是不是有不了解的地方
    4.如果有不了解的 : 和周围的同学一起讨论  找周围学习好的同学问 来问老师
    5.一遍敲笔记 一遍把注释写下来
    6.把你敲得代码删掉,只留注释
    7.不要看笔记,对照注释默写代码
操作系统的作用:
    1:隐藏丑陋的硬件端口,提供;良好的抽象接口给用户更好的体验
    2:管理,调度进程,并将对进程的竞争变得有序
多道技术:
    针对单
    核,实现并发
     3解决多个代码在执行时,抢占资源,对多个进程的切换去运行
    1;时间上的复用:
        在同一时间完成
            a.cpu遇到io阻塞切换至其他进程
            b,cpu处理一个进程时间过长就会切换
    2:空间复用:多个进程占有内存,
    3.在任务之间的切换时根据io 阻塞来切换的.提高了效率
进程在操作系统的三状态:
    就绪 阻塞 运行
        （1）就绪(Ready)状态
    　　     当进程已分配到除CPU以外的所有必要的资源，只要获得处理机便可立即执行，这时的进程状态称为就绪状态。
    　　（2）执行/运行（Running）状态当进程已获得处理机，其程序正在处理机上执行，此时的进程状态称为执行状态。
    　　（3）阻塞(Blocked)状态正在执行的进程，由于等待某个事件发生而无法执行时，便放弃处理机而处于阻塞状态。引起进程阻塞的事件可有多种，例如，等待I/O完成、
                申请缓冲区不能满足、等待信件(信号)等。

分时操作系统:
   操作系统会根据cpu使用的时间来切换,
   时间片:每个人任务分配cpu 执行的时间
   同时执行,每个进程都可以占用cpu 执行,
   能够把几个任务之间的数据隔离开,并且记录执行中的数据状态
   更好的提供了用户体验
串行 和 并行
   # 并发 : 站在多个程序/任务的角度上看的,来回切换去执行,
   # 并行 :多个CPU,多个任务同时在CPU上执行
   # 串行 :一个CPU,代码在这个cpu上一条一条顺序执行
         # 站在CPU执行指令的角度上看的
同步异步
   # 同步 : 执行一个任务,必须要等待这个任务有结果才返回/才进行下一个任务
      # sk.accept
      # conn.recv
      # conn.send
      # login

   # 异步 : 执行一个任务,不必等待这个任务的结果

阻塞非阻塞 : 看cpu有没有停止对这个任务的执行
   # 阻塞 让你的程序会陷入等待的 recv recvfrom accept sleep input acquire

   # 非阻塞
同步阻塞同步非阻塞异步阻塞异步非阻塞

同步阻塞:
   程序必有回应,才能继续接着运行如((accept,recv 然后接收的那一端就不会做然后事情)

同步非阻塞: 在同步运行的时候,不阻塞可以运行其它的进程

异步非阻塞:俩者异步的,并且不阻塞,进程继续执行


阻塞:
阻塞调用是指调用结果返回结果之前,当前线程会被挂起的,函数只有在得到结果后才会将阻塞的线程激活
,而同步调的当前线程是激活的,只是逻辑上当前函数没有返回罢了
    1. 同步调用：apply一个累计1亿次的任务，该调用会一直等待，直到任务返回结果为止，但并未阻塞住（即便是被抢走cpu的执行权限，那也是处于就绪态）;
    2. 阻塞调用：当socket工作在阻塞模式的时候，如果没有数据的情况下调用recv函数，则当前线程就会被挂起，直到有数据为止。


进程与线程区别:

多进程
   多个程序  能够 同时在操作系统中 执行
   多进程 : 开销 数据隔离
一个程序 不太适合开启很多个进程

并发的需求越来越大,多个CPU的出现
   一个新的单位
线程
   线程是进程的一部分
   一个线程必须依赖进程存在
   一个进程之内至少有一条线程
   进程中默认存在的线程 主线程
   也可以在一个进程中开启多个子线程来完成更多的事情
线程 - 轻量级(轻型)进程
   比进程的开销小很多
进程和线程之间的关系
   线程是属于进程


进程是计算机中最小的 资源分配单位
线程是计算机中能被CPU调度的最小单位,计算机中最小的执行单位

多个进程之间的多条线程可不可以利用多核
同一个进程中的多条线程可不可以利用多核
   一个进程之间的多个线程是完全可以利用多核的
正常的进程和线程之间的区别
   进程 : 数据隔离开销大
   线程 : 数据共享开销小






**********进程:
操作系统引入进程的概念的原因:
    从理论上来说,是对正在运行的程序过程的抽象
    从实现的角度 来说,是一种数据结构,目的在于清晰的刻画出动画系统的内在规律
    有效管理合和调度进入计算机系统主内存储存器运行的程序
进程的概念:
    进程:就是计算机关于数据集合的一次活动,是系统进行资源分配基本单位,是操作系统结构的基础,
    进程是一个实体 有内存空间,包括文件区域,数据区域,文本区域执行处理机制的代码,
    堆栈区域储存着活动过程调用的指令和本地变量

    也可以说进程是:
        1.运行中的程序就是一个进程。所有的进程都是通过它的父进程来创建的。因此，运行起来的python程序也是一个进程，
            那么我们也可以在程序中再创建进程。多个进程可以实现并发效果，也就是说，当我们的程序中存在多个进程的时候，
            在某些时候，就会让程序的执行速度变快。
        2.进程是多道技术出现后,为了刻画系统内部出现的动态情况,描述系统内部各道程序活动的规律引出来的一个概练,
            所有多道程序的设计操作系统都是建立在进程的基础上.

进程的特点:
    动态性;进程的实质就是多道程序系统中的一次执行,进程是动态产生,动态的消亡
    并发性:任何进程都可以同其他的进程一起并发执行
    独立性:由于进程是一个独立的运行的基本单位,同时也是系统分配资源和调用的独立单位
    异步性:由于进程间是互相制约的,使用进程具有执行 的时间间断性
    结构特性:进程由程序,数据和进程控制 这三块组成的
        多个不同的进程可以包含相同的程序,一个程序在不同的数据里构成不同的进程,能够得到不同的结果,
        但是执行过程中,程序不能发生改变
    程序可以作为一种软件质料长期存储,而进程是具有一定的生命期
    并行:同时多个进程进行执行  多核的系统
    并发:并发资源有限情况下,是来回切这着进行  单核的必定存在

    同步:
        一个结束了,才能进行下一个程序
    异步:给一个程序发送指令,就不用管了就自己运行自己的

    同步阻塞:
        被等待了,一值在等待着:拿函数来说,该程序一直阻塞在该函数的调用处,就不能继续往下执行
    异步阻塞:在被通知的消息被触发时,就被阻塞在这个等待操作上了

linux:
        理论上: 各个进程的开启和结束互相不影响,不依赖.
            主进程的开启与子进程开启没有任何依赖.
            什么叫进程结束?
            代码运行完毕叫进程结束么? 你的进程空间在内存中真正的消失才算是进程结束.
            子进程是在主进程的基础上创建的,并且结束子进程的时间节点主进程必须要知道.
            僵尸进程: 死而不腐, p1 p2 p3 在代码结束时都没有完全死掉,
            他们会形成一个僵尸进程:僵尸进程只会保存pid,运行时间,状态.
            我的主进程为什么要获取僵尸进程的这些保留的数据呢?
                僵尸进程会占有一点空间,僵尸进程会占有pid进程号,
                僵尸进程的回收,是由主进程发起的.

            孤儿进程?
                你的主进程意外挂了,剩下 p1 p2 p3 就形成 孤儿进程
                所以你的孤儿都会交给'民政局'处理. init 是 Linux 所有进程的主进程.

            僵尸进程有害?有害的.
                僵尸进程他的回收取决于主进程,如果主进程产生了大量的子进程,但是不着急回收这些变成了的僵尸进程.

            孤儿进程有害? 无害 都会被民政局 init 回收.

            具体回收方法:windos 有 waitpid()
            p1.join()源码中 有waitpid()方法.

在python程序中的进程操作
        multiprocessing 模块,分为四个模块:
                1创建进程部分Process() 2进程通信的部分 Queue()
                3进程池的部分 Pool() 4进程之间的数据共享部分 Mannage

在Linux 与windos 系统有区别的:
    在Windows操作系统中由于没有fork(linux操作系统中创建进程的机制)
    ，在创建子进程的时候会自动 import 启动它的这个文件，而在 import 的时候又执行了整个文件。因此如果将process()
    直接写在文件中就会无限递归创建子进程报错。所以必须把创建子进程的部分使用if __name__ ==‘__main__’
    判断保护起来，import 的时候  ，就不会递归运行了。



进程之间的通信:IPC(各种队列)
    列如进程中的队列:
        本类进程之间 的信息是独立的,互不相关,所以想要实现进程之间的通信就得,用到队列  先进先出,put  get
        同样的是通过导入模块来使用
        最重要的特点就是先进先出



进程锁:
   # 抢票的例子
   直接锁一个函数,或者一代码都可以
   那段函数,功能使用到数据了  为了 数据安全就得给它加上锁.

   with lock :
      func()
   因为本身抢票 ,就是一个多并发的,因为数据在操作的过程中是需要时间,网络上的阻塞的,不能并发,只能串行

进程队列
   队列的特点 : 先进先出 进程之间数据安全
   就绪队列 : 由操作系统维护这任务之间谁先被运行的顺序的一个数据结构
   队列的底层 : 管道 + 锁
      # 管道Pipe 是没有锁的 数据不安全的
# from multiprocessing import Pipe
       管道的底层 :
      socket 基于文件地址家族的通信


进程池:Pool
    1 .为什么要有进程池  ?
        在创建进程是需要耗费时间,销毁也需要时间,也就减低了效率
    2 .多个进程能不能利用多核(多个cpu)
           能最多能利用多少个cpu?电脑有多少个cpu就能够最多同时利用多少个进程
            如果我们可以忽略IO操作,这个时候我们起超过cpu个数过多的进程个数反而会降低程序的执行效率

进程池:
概念:对多个任务,只创建对应的几个线程,而不是每一个任务都去创建一个线程:
    异步提交的时候,当几个任务很短暂的时候,就会被第一个进程给执行完了,所以他们的进程id是一样的
    进程池中就没有必要在去创造第二条进程了
    一般用于高级算型的
    同步提交基本不用,一个一个进程去跑的,就会起多个进程

    在进程池中获取返回值  因为进程之间数据本身就是隔离的

    Lock 是从魔块中到入的,把一段代码变为串行,把异步变为同步
    所以加锁保证数据安全
    查票可以并发但是买票就不能了  因为在并发中,cpu切换得很快 而不是
    等一个程序结束了在进行另外一个程序,在写入json 是还写好已经被读了所以就导致一张票多卖


线程:
为什么会有线程
   socket 网络上的服务
   我们希望我们的应用能够在同一时刻做更多的事情
   并且还能共享一段数据
线程:
        概念:是cpu调度的单位  也是轻型的进程
            线程就是依赖于进程 , 在同一个进程中的线程共享进程中的数据

        用法: 用于实现多并发,来回切换比多进程之间的切换还要快,在io阻塞长的话时用进程?
            还是说用多进程,以为多进程是支持多核的,而多线程是不支持多核的()仅限于在python 解释器中pyCharm)

threading
    Thread类
        线程的效率
        线程之间的数据共享
        线程不同于进程的地方 :效率  数据共享  不能在外部被结束(terminate)
        使用面向对象的方式开启线程
        守护线程
    线程的数据安全问题
        GIL锁
        互斥锁
        递归锁
        死锁现象
queue模块
        能够保证数据在多个线程之间进行安全的数据传递
        队列
        栈
        优先级队列
concurrent
        线程池
        进程池



 线程池 :
            这是一个公共的模块
            进程池 线程池
            都可以去用的,高度去用的

队列锁:
锁:
        1:Lock 锁
        2:Rlock递归锁
        3:都会造成死锁的现象,当Lock锁死锁了可以用递归锁先去解决,在考利逻辑问题,把多个变量锁一起
            从根本商 去解决问题

        队列:
            Queue  对列
            fifo   先进先出

进程的代码:
import os
os.getpid()当前进程的id  os.getppid() 父进程的id 

开启进程的俩种方法:

第一种:
from  multiprocessing import Process
import os
def func(name):
    print(f'{name}好嗨哦')
def main():
    print(os.getpid())
if __name__ == '__main__':
    p = Process(target=func,args=(1,))
    p.start()

第二种类的方法:
class Myclass(Process):
    def __init__(self,name):
        super().__init__()
        self.name =name
    def run(self):
        # 子进程的代码都写在这
        a = 1
        b = 2
        print('%s is runing' %self.n)

if __name__ == '__main__':
    p = Myclass('ok')
    p.start()

进程池的异步提交:
apply(函数, args=(参数))
同步调用一般不用
import os
from multiprocessing import Pool
def func(i, ):
    time.sleep(0.1)
    i * i
    print(os.getpid())
if __name__ == '__main__':
    strat = time.time()
    p = Pool()
    一: 异步提交
    for i in range(10):
        p.apply_async(func, (i,))  # apply提交任务 asyncy 异步
    p.close()  # 关闭池子
    p.join()  # z阻塞
    print(time.time() - strat)
    二:
    strat = time.time()
    p_l = []
    for i in range(20):
        p = Process(target=func, args=(1,))
        p.start()
        p_l.append(p)
    for p in p_l:
        p.join()
    print(time.time() - strat)
进程池异步提交:
import time
from multiprocessing import Process, Pool


def func(i):
    i + i
    return '*' * i


if __name__ == '__main__':
    p = Pool()
    lis = []
    # 一
    a = time.time()
    ret = p.map(func, range(5))
    for i in ret:
        print(i)
    print(time.time() - a)
    二
    a = time.time()
    for i in range(5):
        ret = p.apply_async(func, (i,))
        lis.append(ret)
    for ret in lis:
        print(ret.get())
    print(time.time() - a)

    三
    a = time.time()
    for i in range(5):
        ret = p.apply_async(func, (i,))
        lis.append(ret)
    p.close()
    p.join()  # 执行完了一起出来
    for i in lis:
        print(i.get())
    print(time.time() - a)

** ** ** map
import os
from multiprocessing import Pool


def func(i, ):
    time.sleep(0.1)
    i * i
    return "i" * i


if __name__ == '__main__':
    p = Pool()
    re_1 = p.map(func, range(5))  # map 内置了close  与 join
    for i in re_1:
        print(re_1)
'''
生成者消费者模型
import time,random
from multiprocessing import Process,Queue
def consumer(q,name):
    while 1:
        task = q.get()
        if not task:break
        time.sleep(0.1)
        print(f'{name}吃了{task}')
def producer(q,n):
    for i in range(n):
        time.sleep(random.random())
        print(f'生成了{i}个')
        q.put(f'生成了{i}个')
if __name__ == '__main__':
    q = Queue()
    lis = []
    for i in range(5):
        p = Process(target=producer,args=(q,10))#五个生产者
        p.start()
        lis.append(p)
    p1 = Process(target=consumer,args=(q,'alex'))#俩个消费者
    p2 = Process(target=consumer,args=(q,'big'))
    p1.start()
    p2.start()
    for p in lis:
        p.join()
    q.put(None)#为什么叫put(None) 而且因为有俩生产者,要是在生产者的子进程中put(None) 的话不够取 所以在就主进程中俩put(None)
    q.put(None)#应为生产的不够吃,想要结束的话就用ifp判断让消费者不在消费,多少个消费者就多少个put(None)
# 进程中的队列,解决了,进程之间的通信,包括子进程与父进程的通信

#基于socket 用多进程解决并发聊天

# server 端
import socket
from multiprocessing import Process
server = socket.socket()
server.setsockopt(socket.SOL_SOCKET,socket.SOCK_STREAM,1)
server.bind(('127.0.0.1',8888))
server.listen(5)
def talk(conn,client_addr):
    while 1:
        try:
            mag = conn.recv(1024)
            if not mag:break
            conn.send(b'adfs')
        except Exception:
            break
if __name__ == '__main__':
    while 1:
        conn,addr = server.accept()
        p = Process(target=talk,args=(conn,addr))
        p.start()

# 客户端client
client =socket.socket()
client.connect(('127.0.0.1',8888))
while 1:
    client.send(b'sdfsa')
    msg = client.recv(1024)
    print(msg)

#******** 线程的代码
'''下面代码为了证明:子线程与父线程的数据共享的
from threading import Thread
n =10
def fucn():
    global n
    n -=1#----->子线程n 的变化
lis = []
for i in range(10):
    t = Thread(target=fucn)#开启十个线程
    t.start()
    lis.append(t)
    print(n)
for i in lis:
    i.join()
print(n)  #-----主线程n
'''


# 主线程会等待子线程结束后才结束
#查看线程名
import time
from threading import Thread
def func():
    time.sleep(1)
    print(' in func')

t = Thread(target=func)
t.start()
print(t.ident)#线程地址
print(t.name)#线程名称

类方式 查看线程名
import time
class MyThread(Thread):
    def __init__(self,i):
        super().__init__()
    def run(self):
        time.sleep(1)
        print('in mythread',self.name,self.ident)
for i in range(5):
    t = MyThread(i) #需要传参的话就需要,__init__
    t.start()

import time
from threading import currentThread,active_count,enumerate,Thread
def func():
    time.sleep(1)
    #导入currentThread直接使用,直接在函数中点  得到线程名,线程地址
    print('in func',currentThread().name,currentThread().ident)
t = Thread(target=func)
t.start()
print(t.ident)#线程名
print(t.name)#线程地址

def foo():
    time.sleep(1)
    print(' in func',currentThread().name,currentThread().ident)
t =Thread(target=func)
print(enumerate())    # 当前所有活着的线程对象组成的列表
print(active_count()) # 统计当前所有活着的线程对象的个数 len(enumerate)
print(t.ident)  # 线程id
print(t.name)   # 线程名

线程的守护进程
import time
from threading import Thread
def func():
    while 1:
        time.sleep(1)
        print('in func')
def son():
    print('son start ')
    time.sleep(1)
t = Thread(target=func)
t.setDaemon(True)
t.start()
Thread(target=son,).start()
time.sleep(4)
线程是否存在数据安全问题
    数据共享
GIL锁 :能够保证在同一时刻 不可能有两个线程 同时执行    CPU指令
为什么有了GIL还需要手动加锁
为什么append这样的方法和+=这样的方法在数据安全性问题上是不一样
    由于append是一个完整的指令过程,执行了就相当于添加,不执行就还没添加
    += 先执行+法,再对结果进行赋值

线程的数据安全:
from threading import Lock
import dis
l = []
def func():
    l.append(1)
a= 0
def func2():
    global a
    with lock:
        a +=1
lock =Lock()
dis.dis(func2())
print(a)


from threading import Thread,Lock
import os,time
def work():
    global n
    with lock:
        temp = n
        time.sleep(0.1)
        n = temp - 1
        n = temp - 1
if __name__ == '__main__':
    n =10
    l =[]
    for i in range(5):
        p = Thread(target=work,args=(lock,))
        l.append(p)
        p.start()
    for p in l :
        p.join()
    print(n)

#科学家吃面的问题
import time
from threading import Lock,Thread
noodle_lock = Lock()
fork_lock = Lock()
fork = 10
noodle = 20
def eat1(name):
    noodle_lock.acquire()
    print('%s拿到面了'%name)
    fork_lock.acquire()
    print('%s拿到叉子了' % name)
    noodel =fork + noodle
    time.sleep(0.1)
    print('%s吃到面了'%name)
    fork_lock.release()
    print('%s放下叉子了' % name)
    noodle_lock.release()
    print('%s放下到面了'%name)

def eat2(name):
    fork_lock.acquire()
    print('%s拿到叉子了' % name)
    noodle_lock.acquire()
    print('%s拿到面了'%name)
    noodel =fork + noodle
    time.sleep(0.1)
    print('%s吃到面了'%name)
    noodle_lock.release()
    print('%s放下到面了' % name)
    fork_lock.release()
    print('%s放下叉子了' % name)

# for i in ['yuan','alex','wusir','太亮']:
Thread(target=eat1,args=('yuan',)).start()
Thread(target=eat2,args=('alex',)).start()
Thread(target=eat1,args=('wusir',)).start()
Thread(target=eat2,args=('太亮',)).start()


# 递归锁
# 使用递归锁可以快速的解决死锁问题
import time
from threading import RLock,Thread
fork_lock = noodle_lock = RLock()
fork = 10
noodle = 20
def eat1(name):
    noodle_lock.acquire()
    print('%s拿到面了'%name)
    fork_lock.acquire()
    print('%s拿到叉子了' % name)
    noodel =fork + noodle
    time.sleep(0.1)
    print('%s吃到面了'%name)
    fork_lock.release()
    print('%s放下叉子了' % name)
    noodle_lock.release()
    print('%s放下到面了'%name)

def eat2(name):
    fork_lock.acquire()
    print('%s拿到叉子了' % name)
    noodle_lock.acquire()
    print('%s拿到面了'%name)
    noodel =fork + noodle
    time.sleep(0.1)
    print('%s吃到面了'%name)
    noodle_lock.release()
    print('%s放下到面了' % name)
    fork_lock.release()
    print('%s放下叉子了' % name)

# for i in ['yuan','alex','wusir','太亮']:
Thread(target=eat1,args=('yuan',)).start()
Thread(target=eat2,args=('alex',)).start()
Thread(target=eat1,args=('wusir',)).start()
Thread(target=eat2,args=('太亮',)).start()


# 用互斥锁 来解决问题
# 两个资源作为一个资源锁起来
import time
from threading import Lock,Thread
lock = Lock()
fork = 10
noodle = 20
def eat1(name):
    lock.acquire()
    print('%s拿到面了'%name)
    print('%s拿到叉子了' % name)
    noodel =fork + noodle
    time.sleep(0.1)
    print('%s吃到面了'%name)
    print('%s放下叉子了' % name)
    print('%s放下到面了'%name)
    lock.release()

def eat2(name):
    lock.acquire()
    print('%s拿到叉子了' % name)
    print('%s拿到面了'%name)
    noodel =fork + noodle
    time.sleep(0.1)
    print('%s吃到面了'%name)
    print('%s放下到面了' % name)
    print('%s放下叉子了' % name)
    lock.release()

# for i in ['yuan','alex','wusir','太亮']:
Thread(target=eat1,args=('yuan',)).start()
Thread(target=eat2,args=('alex',)).start()
Thread(target=eat1,args=('wusir',)).start()
Thread(target=eat2,args=('太亮',)).start()



1.死锁现象
    由于多个锁对多个变量管理不当 产生的一种现象
2.Lock 互斥锁
    在一个线程内只能被acquire一次
3.RLock 递归锁
    在一个线程内可以被acquire多次,必须acquire多少次,release多少次





# 队列:
# import queue
# 
fifo 先进先出
q = queue.Queue()
q.get()
q.get_nowait()
q.put()
q.put_nowait()

lifoqueue
后进先出的队列 = 栈  --> 算法
lifoq = queue.LifoQueue()
lifoq.put(1)
lifoq.put(3)
lifoq.put(2)
lifoq.put(0)
print(lifoq.get())
print(lifoq.get())

优先级队列
pq = queue.PriorityQueue()#优先级
pq.put((2,'wusir'))
pq.put((1,'yuan'))
pq.put((1,'alex'))
pq.put((3,'太亮'))
print(pq.get())
print(pq.get())
print(pq.get())
在put()中按第一个数字的大小出来的, 出现了俩个大小一样的,元组里边的第二元素的ascll码来排  最小的先出去
可以用去写QQ会员这样的软件



线程池代码
import  time
from  concurrent.futures import ThreadPoolExecutor as Executor ,ProcessPoolExecutor
-------------------------------->ThreadPoolExecutor as Executor() 或者ProcessPoolExecutor as Executor() 这样就可以无缝去使用
def func(i):
    time.sleep(1)
    print('in son thread',i)
#$****(1)
if __name__ == '__main__':
    tp = Executor()  #  线程池
    tp.map(func,range(8))   #map 函数特别注意的是,参数位置,函数的位置不是关键字参数 传参的是可迭代对象
    print('所有的任务都快执行完成了')
#******(2)   俩种的效果是一样的
if __name__ == '__main__':
    tp =Executor()
    for i in range(5):
        tp.submit(func,i)#这个位置直接传参  #相当于 异步提交
    tp.shutdown() #写话主线程就会等待子线程完成以后在执行主线程  相当于close 和 join
    print('这里跑的是主线程')


#如何获取返回值的
import  time,os
from  concurrent.futures import ThreadPoolExecutor as Executor ,ProcessPoolExecutor
from threading import currentThread
def func(i):
    i + i
    time.sleep(1)
    print(os.getpid(),os.getppid())
    return '^'*i
if __name__ == '__main__':
    p = Executor(4)

    第一种使用使用map提交任务 获取返回值
    ret = p.map(func,range(3))#ret generator object 生成对象
    for i in ret:
        print(i)
    print('这是主线程---->',os.getpid(),os.getppid())

    第二种使用submit提交任务,获取返回值
    l =[]
    for i in  range(5):
        ret = p.submit(func,i)
        l.append(ret)
    for i in l:
        print(i.result())


def func(i):
    i + i
    time.sleep(1)
    print(currentThread().name,currentThread().ident)
if __name__ == '__main__':
    p = Executor()
    p.map(func,range(6))
    print('这是主线程------>',currentThread().name,currentThread().ident)

# 
# 
#回调函数:
import  time,os,random,requests
from  concurrent.futures import ThreadPoolExecutor as Executor ,ProcessPoolExecutor
from threading import currentThread,Thread
def back(ret):
    print(ret.result())

def son_func(i):
    time.sleep(random.random())
    return i**i
p = Executor()
for i in range(5):
    ret =p.submit(son_func,i)#得到函数son_func返回值
    ret.add_done_callback(back)#返回值传个back

def get(url):
    obj = requests.get(url)
    if requests.status_codes == 200:
        return {'url':url,'text':obj.text}
def parse_page(res):
    res = res.result()
    parse_res = 'url:<%s> size:[%s]
' % (res['url'], len(res['text']))
    with open('db.txt','a') as f :
        f.write(parse_res)
if __name__ == '__main__':
    urls =[
        'https://www.baidu.com',
        'https://www.python.org',
    ]
    p = Executor()
    for url in urls:
        p.submit(get).add_done_callback(parse_page)


#二分法查找
# lis =[1,2,13,14,25,61,73,85,97,123,345,678,1234,5678,6789]

#第一种纯逻辑算法:
n =345
lift = 0
right  = len(lis) - 1
count = 0
while lift<=right:
    middle = (lift + right) // 2
    if n > lis[middle]:
        lift = middle +1
    elif n < lis[middle] :
        right = middle - 1
    else:
        print(count)
        print(middle)
        break
    count +=1
else:
    print('不存在')
#
#第二种:
lis =[1,2,13,14,25,61,73,85,97,123,345,678,1234,5678,6789]
def func(left,right,n):
    middle = (left + right) // 2
    if left>right:     #----->边界问题 当数不存在的时候就找不到,left 与right 下标都变互逆了
        print('没找到')
        return -1
    if n > lis[middle]:
        left = middle + 1
    elif n < lis[middle]:
        right = middle -1
    else:
        return middle
    return func(left,right,n)
p = func(0,len(lis) - 1,1)
print(p)

# 第三种:改变列表
lis =[1,2]
left = 0
right = len(lis) - 1
middle = (left + right) // 2
lis=lis[:middle-1]
print(lis)

lis =[1,2,13,14,25,61,73,85,97,123,345,678,1234,5678,6789]
def func(lis,n):
    left = 0
    right = len(lis) - 1
    middle = (left + right) // 2
    if right <=0:  #这个位置很关键
        print('没有找到')
        return -1
    if n < lis[middle]:
        lis=lis[:middle-1]  #边界问题
    elif n > lis[middle]:
        lis  = lis[middle+1:]#中间位置
    else:
        print('找到了')
        return lis
    func(lis,n)
func(lis,1234)

dic = {'怎么':'对方是否','1':123,'78':213}



print(dic.keys())#dict_keys(['怎么', '1', '78'])  这个列表是高仿列表是不能够去 操作的

print(dic.items())#dict_items([('怎么', '对方是否'), ('1', 123), ('78', 213)])#同样的这个列表且套元组的是不能够去使用的

#三级菜单:

dic = {'北京':{'朝阳':{'朝阳大妈':'朝阳纪委','朝阳群众':'描线'},'海淀':{'海淀区':'海胆'},'昌平':{'沙河':'黄河','黄山':'一'}},
       '上海':{'上海滩':{'发哥':'赌神'},'歌剧院':{'歌星':'不知道'}}}
递归方法
def treeLM(dic):
    while 1:
        for i in dic:print(i)
        key = input('请输入你选择的地址:').strip()
        if key == 'b' or key == 'q':return key
        elif key in dic.keys() and dic[key]:
            ret =treeLM(dic[key])
            if ret == 'q':return 'q'
        elif (not dic.get(key)) or (not dic[key]):
            continue
        else:
            print('好好输入')
treeLM(dic)

l =[dic]
while l:
    for i in l[-1]:print(i)
    k = input('>>>:').strip()
    if k in l[-1].keys() and l[-1][k]:l.append(l[-1])
    elif k == 'b':l.pop()
    elif k == 'q':break
    else:continue

            lifo  先进后出  栈   用于递归的 的算法上 三级菜单

        数据的安全:
            对于list  dic  这样的数据  通过增删改查 这样的操作  是不会发生数据不安全的,
            而  -= +=  *= 这样的挥发生数据安全问题的,  因为在算当中 会开回切换, 对于GIL锁来说
            只有一个进程把锁还回来 另外一个程序在可以被cpu运行调度 所以没有其他锁的情况下就会数据不安全


注意:主线程会等待子线程结束之后才结束

守护线程 :(代码t = Thread(target=func)
            t.setDaemon(True) ---设置当前线程为守护线程
    守护进程:守护进程会等待主进程的代码结束而结束
    守护线程 :守护线程会等待主线程的结束而结束
        如果主线程还开启了其他子线程,那么守护线程会守护到最后
    主进程必须后结束,回收子进程的资源
    线程是属于进程的,主线程如果结束了,那么整个进程就结束了
　　
　　　当只有主线程 与一条守护线程 的时候  主线程 直接运行结束,不用等守护线程,运行 ,因为守护线程本身就是为了守护主线程而产生的,主线程安全运行,那么守护线程的
　　的使命也就是随着结束了.

    过程
    主线程结束依赖两个事儿 (自己的代码执行完毕,非守护的子线程执行完毕)
    -->主线程结束,进程也结束了
    -->这个进程中的所有线程都结束了,所有的守护线程也就不存在了


锁:
在python中的线程 是不能利用多个CPU -- 全局解释器锁 GIL
import dis  # 内置模块 能够查看python代码翻译成的机器语言

GIL锁:
    GIL锁 :能够保证在同一时刻 不可能有两个线程 同时执行  CPU指令
面试题:
    有了这个锁 多线程是不是就没用了?
   socket recv accept  在高IO操作的时候多线程仍然比多进程好用很多很多
GIL全局解释器锁 是 Cpython解释器中的
   Jpython pypy 都支持多线程访问多核
为什么这个锁要加上啊? 历史遗留问题 + python是解释型语言的现实情况
为什么不把这个锁去掉啊? 尝试着去掉过  效果不好
多线程不能利用多核这件事情如何弥补,如何看待?
   1.不能利用多核 并不能说明在解决高IO操作的程序中python是有问题的

   2.如果我要解决的是高计算的场景呢?
               1.多进程 2.搭建集群和分布式系统