基于Python与单片机隧道环境

转载

mob64ca14017c37 2024-09-14 09:31:18

文章标签 基于Python与单片机隧道环境子线程进程池多任务 文章分类 Python 后端开发

文章目录

一、复用TCp服务端和TCP接收端
二、模块导入
一、with上下文管理器
二、多任务
一、互斥锁和GIL
二、进程池
进程
线程
协程
一、linux文件目录
二、linux命令

一、复用TCp服务端和TCP接收端

二、模块导入

import module

# 模块导入方式一
import a_module
a_module.func()

import package.module

# 模块导入方式二
import packet_A.module_A
packet_A.module_A.func()

from module import 成员

# 模块导入方式三
from a_module import func
func()

from module import *

# 模块导入方式四
# 此方法类似于深拷贝， 将所有的内容导过来, 但也有不好的，容易产生命名冲突。
from a_module import *
func()

from package import module

# 模块导入方式五
from packet_A import module_A
module_A.func()

from package.module import 成员

# 模块导入方式六
from packet_A.module_A import func
func()

一、with上下文管理器

with语句
__ exit __参数：
__ enter __参数：

import time


class MyOpen(object):
    def __init__(self, file, mode):
        self.__file = file
        self.__mode = mode

    def __enter__(self):
        print('__enter__run ...打开文件')
        self.__handle = open(self.__file, self.__mode)
        return self.__handle         #return 的返回值在with接收

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('__exit__... run...关闭文件')
        if exc_type:
            print('有错误')
        self.__handle.close()
        return True
        #return False 


with MyOpen('test', 'r') as f:
        f.write('python 大家好')
        time.sleep(3)
print('over')

二、多任务

操作系统同时完成多项任务处理

并发：指的是任务数多于cpu核数，通过操作系统的各种任务调度算法，实现用多个任务“一起”执行

并行：当任务数小于或者等于cpu核数时，每一个任务都有对应的cpu来处理执行，即任务真的是一起执行的

继承Thread类

import threading
import time


def download_music():
    """模拟下载歌曲，需要5秒钟下载完成"""
    for i in range(5):
        time.sleep(1)  # 休眠1秒
        print("---正在下载歌曲%d---" % i)


def play_music():
    """模拟播放歌曲，需要5秒钟下载完成"""
    for i in range(5):
        time.sleep(1)  # 休眠1秒
        print("---正在播放歌曲%d---" % i)


def main():
   
    # 创建线程对象t1
    # target: 指向新开启的线程要执行的代码
    t1 = threading.Thread(target=download_music)
    t2 = threading.Thread(target=play_music)

    t1.start()  # 启动线程，既然线程开始执行
    t2.start()


if __name__ == '__main__':
    main()

一、互斥锁和GIL

GIL 是Python 解释层面的锁，解决解释器中多个线程的竞争资源问题

二、进程池

如果要使用Pool创建进程，就需要使用multiprocessing.Manager()中的Queue()，而不是multiprocessing.Queue()，否则会得到一条如下的错误信息：

# -*- coding:utf-8 -*-
from multiprocessing import Pool
import os, time, random

def worker(msg):
    t_start = time.time()
    print("%s开始执行,进程号为%d" % (msg,os.getpid()))
    # random.random()随机生成0~1之间的浮点数
    time.sleep(random.random()*2) 
    t_stop = time.time()
    print(msg,"执行完毕，耗时%0.2f" % (t_stop-t_start))

po = Pool(3)  # 定义一个进程池，最大进程数3
for i in range(0,10):
    # Pool().apply_async(要调用的目标,(传递给目标的参数元祖,))
    # 每次循环将会用空闲出来的子进程去调用目标
    po.apply_async(worker,(i,))

print("----start----")
po.close()  # 关闭进程池，关闭后po不再接收新的请求
po.join()  # 等待po中所有子进程执行完成，必须放在close语句之后
print("-----end-----")

进程

进程是操作系统进行资源分配和调度的一个基本单位.

线程

是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.

1.子线程何时开启，何时运行
当调用thread.start()时开启线程，再运行线程的代码
2.子线程何时结束
子线程把target指向的函数中的语句执行完毕后，或者线程中的run函数代码执行完毕后，立即结束当前子线程
3.查看当前线程数量
通过threading.enumerate()可枚举当前运行的所有线程
4.主线程何时结束
所有子线程执行完毕后，主线程才结束