# .需要认证

    # 程序和用户打交道的时候才会用到用户认证

    # 对所有的客户端进行统一的认证

        #

# 我现在要做的事情

    # 写一个server端

    # 写一个client端 特殊的 符合我的server端要求的代码

# .client端不会被其他机器获取到

# .即使客户端的代码不在别人手上 有心人仍然可以非法的访问我们的程序

# hashlib

# 密钥

# 随机的字符串

# server 密钥 发送一个随机字符串，密钥为盐，对随机字符串进行摘要 得到一个字符串结果

# client 密钥 密钥为盐，对随机字符串进行摘要 得到一个字符串结果 将结果发送回server端

import os

import hashlib

import hmac

import socket

def auth(conn):

    num_file = os.urandom()  # 产生一个32位的数字

    key = b'alex'

    obj = hmac.new(key, num_file)

    conn.send(num_file)

    ret = conn.recv()

    return (hmac.compare_digest(obj.digest(), ret))

sk =socket.socket()

sk.bind(('127.0.0.1',))

sk.listen()

conn, addr = sk.accept()

auth(conn)

conn.close()

sk.close()

import os

import socket

import hmac

def auth(sk):

    file_len = sk.recv()

    print(file_len)

    key = b'alex'

    send_msg = hmac.new(key, file_len)

    sk.send(send_msg.digest())

sk =socket.socket()

sk.connect(('127.0.0.1',))

auth(sk)

sk.close()

import time

import sys

for i in range(,,):

     time.sleep(0.1)

     char_num = i//2      #打印多少个'*'

     per_str = '\r%s%% : %s\n' % (i, '*' * char_num) if i ==  else '\r%s%% : %s'%(i,'*'*char_num)

     print(per_str,end='')

print('其他的内容')

file_size =

for recevive_num  in range(file_size+):

    time.sleep(0.01)

    done = int( * recevive_num / file_size)

    sys.stdout.write("\r[%s%s] %d%%" % ('█' * done, ' ' * ( - done),  * recevive_num / file_size))

print('\n')

print('ok')

fsize =

old_time = time.time() - 0.00001

new_time = time.time()

for send_count in range(fsize+):

    time.sleep(0.1)

    float_rate = send_count / fsize

    rate = round(float_rate * , )

    sys.stdout.write(

        '\r    {}% |{}| {}MB {}MB/s'.format(rate, '█' * int(rate / ), round(send_count /  ** , ),

                                            (round(send_count /  **  / (new_time - old_time), ))))

    # send_count += 

# I/O操作

# 文件、网络

# i = input 输入

    # 从任何其他地方 --> 内存

        # 读文件、json.load

        # 从网络上接收信息

# o = output 输出

    # 内存 --> 放到任何其他地方

        # 写文件、json.dump

        # 向网络上发送 send sendto

# cpu

    # 主要用来做计算用

# 内存

    # 存储数据 断电消失 存取速度快

# 硬盘

    # 存储数据 读取速度慢 永久存储

# 如何提高cpu的利用率

狭义定义：进程是正在运行的程序的实例（an instance of a computer program that is being executed）。

广义定义：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。

先来先服务（FCFS）调度算法是一种最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。FCFS算法比较有利于长作业（进程），而不利于短作业（进程）。由此可知，本算法适合于CPU繁忙型作业，而不利于I/O繁忙型的作业（进程）。

短作业（进程）优先调度算法（SJ/PF）是指对短作业或短进程优先调度的算法，该算法既可用于作业调度，也可用于进程调度。但其对长作业不利；不能保证紧迫性作业（进程）被及时处理；作业的长短只是被估算出来的。

时间片轮转(Round Robin，RR)法的基本思路是让每个进程在就绪队列中的等待时间与享受服务的时间成比例。在时间片轮转法中，需要将CPU的处理时间分成固定大小的时间片，例如，几十毫秒至几百毫秒。如果一个进程在被调度选中之后用完了系统规定的时间片，但又未完成要求的任务，则它自行释放自己所占有的CPU而排到就绪队列的末尾，等待下一次调度。同时，进程调度程序又去调度当前就绪队列中的第一个进程。

      显然，轮转法只能用来调度分配一些可以抢占的资源。这些可以抢占的资源可以随时被剥夺，而且可以将它们再分配给别的进程。CPU是可抢占资源的一种。但打印机等资源是不可抢占的。由于作业调度是对除了CPU之外的所有系统硬件资源的分配，其中包含有不可抢占资源，所以作业调度不使用轮转法。

在轮转法中，时间片长度的选取非常重要。首先，时间片长度的选择会直接影响到系统的开销和响应时间。如果时间片长度过短，则调度程序抢占处理机的次数增多。这将使进程上下文切换次数也大大增加，从而加重系统开销。反过来，如果时间片长度选择过长，例如，一个时间片能保证就绪队列中所需执行时间最长的进程能执行完毕，则轮转法变成了先来先服务法。时间片长度的选择是根据系统对响应时间的要求和就绪队列中所允许最大的进程数来确定的。

      在轮转法中，加入到就绪队列的进程有3种情况：

      一种是分给它的时间片用完，但进程还未完成，回到就绪队列的末尾等待下次调度去继续执行。

      另一种情况是分给该进程的时间片并未用完，只是因为请求I/O或由于进程的互斥与同步关系而被阻塞。当阻塞解除之后再回到就绪队列。

      第三种情况就是新创建进程进入就绪队列。

      如果对这些进程区别对待，给予不同的优先级和时间片从直观上看，可以进一步改善系统服务质量和效率。例如，我们可把就绪队列按照进程到达就绪队列的类型和进程被阻塞时的阻塞原因分成不同的就绪队列，每个队列按FCFS原则排列，各队列之间的进程享有不同的优先级，但同一队列内优先级相同。这样，当一个进程在执行完它的时间片之后，或从睡眠中被唤醒以及被创建之后，将进入不同的就绪队列。  

时间片轮转法

时间片轮转(Round Robin，RR)法的基本思路是让每个进程在就绪队列中的等待时间与享受服务的时间成比例。在时间片轮转法中，需要将CPU的处理时间分成固定大小的时间片，例如，几十毫秒至几百毫秒。如果一个进程在被调度选中之后用完了系统规定的时间片，但又未完成要求的任务，则它自行释放自己所占有的CPU而排到就绪队列的末尾，等待下一次调度。同时，进程调度程序又去调度当前就绪队列中的第一个进程。

      显然，轮转法只能用来调度分配一些可以抢占的资源。这些可以抢占的资源可以随时被剥夺，而且可以将它们再分配给别的进程。CPU是可抢占资源的一种。但打印机等资源是不可抢占的。由于作业调度是对除了CPU之外的所有系统硬件资源的分配，其中包含有不可抢占资源，所以作业调度不使用轮转法。

在轮转法中，时间片长度的选取非常重要。首先，时间片长度的选择会直接影响到系统的开销和响应时间。如果时间片长度过短，则调度程序抢占处理机的次数增多。这将使进程上下文切换次数也大大增加，从而加重系统开销。反过来，如果时间片长度选择过长，例如，一个时间片能保证就绪队列中所需执行时间最长的进程能执行完毕，则轮转法变成了先来先服务法。时间片长度的选择是根据系统对响应时间的要求和就绪队列中所允许最大的进程数来确定的。

      在轮转法中，加入到就绪队列的进程有3种情况：

      一种是分给它的时间片用完，但进程还未完成，回到就绪队列的末尾等待下次调度去继续执行。

      另一种情况是分给该进程的时间片并未用完，只是因为请求I/O或由于进程的互斥与同步关系而被阻塞。当阻塞解除之后再回到就绪队列。

      第三种情况就是新创建进程进入就绪队列。

      如果对这些进程区别对待，给予不同的优先级和时间片从直观上看，可以进一步改善系统服务质量和效率。例如，我们可把就绪队列按照进程到达就绪队列的类型和进程被阻塞时的阻塞原因分成不同的就绪队列，每个队列按FCFS原则排列，各队列之间的进程享有不同的优先级，但同一队列内优先级相同。这样，当一个进程在执行完它的时间片之后，或从睡眠中被唤醒以及被创建之后，将进入不同的就绪队列。  

时间片轮转法

并行 : 并行是指两者同时执行，比如赛跑，两个人都在不停的往前跑；（资源够用，比如三个线程，四核的CPU ）

并发 : 并发是指资源有限的情况下，两者交替轮流使用资源，比如一段路(单核CPU资源)同时只能过一个人，A走一段后，让给B，B用完继续给A ，交替使用，目的是提高效率。

区别:

并行是从微观上，也就是在一个精确的时间片刻，有不同的程序在执行，这就要求必须有多个处理器。

并发是从宏观上，在一个时间段上可以看出是同时执行的，比如一个服务器同时处理多个session。