混合编程之多线程

【云脚本++】可以把所有代码全部挂写在网络上的强大脚本神器(支持VBS,JS多线程混合编程) 云脚本++,可以把所有代码全部挂在网络上的脚本工具。 支持JS VBS多线程混合编程。已测试,支持XP以后的系统(之前的没测试) 执行文件仅64KB就能拥有全世界,所有库都可以放网上,需要哪个加载哪个: 文档已经写了一部分(写例子太懒了,希望有人愿意边学习边代写一下哈哈,大家看附件里面的示例吧) 附件里面已经放了例子,其中3个例子最典型,学好了基本就会用了 附件里面已经放了VBS版的控制台调试器。直接输入代码即可,也可以用来调试别人的DLL(支持按键精灵官方DLL)... 阅读详情

前言: 小白一个, 没有系统性的学习过python网络通信,只是单纯的cv加修改代码,仅作留念以及参考用,感谢互联网博主们和bito插件,使得chatGPT得以免费使用.
另外该多线程传输图片的速度比没有多线程执行还满,后续不对python服务端做优化,而改为C++服务端实现.写出来继续再分享把

前篇博客地址

python客户端

采用生存者消费者模式、模式2和joinablequeue库.
客户端实现还是比较简单的,麻烦在server端

import pickle
import time
from multiprocessing import Process, JoinableQueue
from queue import Queue

from multiprocessing.connection import Client, Listener

from client_apart import draw_box
from image import plot_boxes, img_encode
import os
from natsort import ns, natsorted

host = 'localhost'
port = 9006
total_time = 0


def img_product(img_queue, path, path_mode='image'):
    if path_mode == 'image':
        img = img_encode(path)
        img_obj = {'frame_num': 1, 'image': img}  # need frame_num?
        img_queue.put(img_obj)
    elif path_mode == 'dir':
        dir_list = os.listdir(path)
        files = natsorted(dir_list, alg=ns.PATH)  # 顺序读取文件名
        i = 1
        for filename in files:
            img_path = path + '/' + filename
            img = img_encode(img_path)
            img_obj = {'frame_num': i, 'image': img}  # need frame_num?
            i += 1
            img_queue.put(img_obj)
        img_queue.put({'frame_num': 0, 'image': "end"})  # end signal 
    img_queue.join()


def server_consumer(img_queue):
    # 1. send data
    while True:
        img_obj = img_queue.get()
        if img_obj is None:
            client.close()  # avoid connection-reset-by-peer
            break  # exit end
        data_bytes = pickle.dumps(img_obj)
        start = int(round(time.time() * 1000))
        start_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
        client.send(data_bytes)  # 40ms/per send img
        # print('send cost time: ', (end - start))
        img_queue.task_done()
        try:
            det_result = client.recv()
            end = int(round(time.time() * 1000))
            end_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
            print('recv cost time: ', (end-start))
        except EOFError:
            break
        det_result = pickle.loads(det_result)
        draw_box(det_result, img_obj)


if __name__ == '__main__':
    client = Client((host, port))
    Listener()
    img_dir = './data'
    one_img = './data/Enterprise001.jpg'
    mode = 'dir'

    img_jq = JoinableQueue()
    producer = Process(target=img_product, args=(img_jq, img_dir, mode,))
    consumer = Process(target=server_consumer, args=(img_jq,))
    consumer.daemon = True  # set daemon but not set join()

    producer.start()
    consumer.start()

    producer.join()

Python服务端

此处接受图片和发送结果线程处在一个类内,使得可以共享一个Listener,来自chatGPT的idea.

from ctypes import *
import ctypes
import time
import pickle
from PHeader import *

import cv2
import numpy as np
from multiprocessing.connection import Listener
from multiprocessing import JoinableQueue, Process, Queue, connection
import threading


class ListenerThread(threading.Thread):
    def __init__(self, address, data_handler, lib):
        super().__init__()
        self.daemon = True
        self.address = address
        self.data_handler = data_handler
        self.lib = lib
        self.listener = Listener(self.address, backlog=5)
        self.conn = None
        self.is_running = True
        
    def run(self):
        print('Listening on', self.listener.address)
        while self.is_running:
            try:
                self.conn = self.listener.accept()  # ready to accept data continually
                print('Connected by', self.listener.last_accepted)
                t1 = threading.Thread(target=self.receive_data)
                t2 = threading.Thread(target=self.send_result)
                t1.start()
                t2.start()
                t1.join()
                t2.join()
            except OSError as e:
                if e.errno != 98:  # Address already in use
                    raise
                print('Address already in use, retrying in 1 second...')
                time.sleep(1)
        

    def destroy_Model(self):  # when qt send a signal
        self.lib.interface_destoryThread()

    def receive_data(self):
        time_cost1 = 0
        while True:
            try:
                start = int(round(time.time() * 1000))
                received_bytes = self.conn.recv()  # recv Client data
                end = int(round(time.time() * 1000))
                print('recv time cost: ', end-start)
                time_cost1 += end-start
                img_dict = pickle.loads(received_bytes)
                if img_dict["frame_num"] == 0:
                    print("receive's thread already receive all data, close thread!!")
                    print("recv: ", time_cost1)
                    self.lib.interface_setEmptyFlag()  # make send thread break
                    break
                img_dict['image'] = cv2.imdecode(img_dict['image'], cv2.IMREAD_COLOR)
                self.data_handler.sendImgtoC(self.lib, img_dict, 0)  # prepare to send img
            except EOFError:
                print('Connection closed')
                self.conn.close()
                break

    def send_result(self):
        time_cost1 = 0
        time_cost2 = 0
        while True:
            self.lib.interface_getClsQueue.restype = ObjClassifyOutput
            start = int(round(time.time() * 1000))
            output = self.lib.interface_getClsQueue()  # get result from model
            end = int(round(time.time() * 1000))
            time_cost1 += end-start
            print('get cls time cost: ', end-start)
            if output.object_list.object_num >= 0:
                cls_result = self.data_handler.CtoP(output)
                cls_result = pickle.dumps(cls_result)
                start = int(round(time.time() * 1000))
                self.conn.send(cls_result)
                end = int(round(time.time() * 1000))
                print('send time cost: ', end-start)
                time_cost2 += end-start
            elif output.object_list.object_num == -1:   # queue is empty for now
                time.sleep(0.04)
                continue
            elif output.object_list.object_num == -2:   # all data is classify
                print("send's thread alreay handle all data, close thread!!")
                print("cls: ", time_cost1, ' send: ', time_cost2)
                # self.close()
                break

    def close(self):  # useless for now
        self.conn.close()
        # self.listener.close()
        self.run()


class DataHandler:
    def __init__(self):
        self.data = None

    def CtoP(self, output):  # 将模型结果解析为python列表
        # [cv_object_list: [cv_object: [cv_box: [] ]]]
        cv_object_list = []
        cls_out = []
        obj_list = output.object_list
        if obj_list.object_num != 0:
            for i in range(obj_list.object_num):
                cv_box = []
                cv_object = []
                obj = obj_list.object[i]
                # bbox
                cv_box.append(obj.bbox.left_top_x)
                cv_box.append(obj.bbox.left_top_y)
                cv_box.append(obj.bbox.w)
                cv_box.append(obj.bbox.h)
                cv_object.append(cv_box)
                # classes/objectness/prob
                cv_object.append(obj.classes)
                cv_object.append(obj.objectness)
                prob = POINTER(c_float)(obj.prob)
                cv_object.append(prob.contents.value)
                # cv_object
                cv_object_list.append(cv_object)
            cv_object_list.append(obj_list.object_num)

            # cv_object_list
            cls_out.append(cv_object_list)
        return cls_out

    def sendImgtoC(self, lib, img_dict, i):
        lib.interface_receive.argtypes = [PythonMat]
        # 1. combine info to img
        pi = PythonMat()
        pi.frame_num[0] = img_dict["frame_num"]
        img = img_dict['image']
        # 1.1 set width/height
        PARAM = c_int * 32
        height = PARAM()
        height[0] = img.shape[0]
        pi.height = height
        width = PARAM()
        width[0] = img.shape[1]
        pi.width = width
        # 1.2 set Mat
        frame_data = np.asarray(img, dtype=np.uint8)
        frame_data = frame_data.ctypes.data_as(c_char_p)
        pi.frame[0] = frame_data
        # 2. send img to detect model
        lib.interface_receive(pi)


if __name__ == '__main__':
    address = ('localhost', 9006)
    data_handler = DataHandler()
    ll = ctypes.cdll.LoadLibrary
    lib = ll("../../lib/libDetClsController.so")  # create a C lib
    listener_thread = ListenerThread(address, data_handler, lib)
    listener_thread.start()
    try:
        det_process = threading.Thread(target=lib.interface_initDetectImage)
        cls_process = threading.Thread(target=lib.interface_initClassifyImage)
        det_process.start()
        cls_process.start()
        det_process.join()  # need a break signal
        cls_process.join()
    except KeyboardInterrupt:
        # 程序被强制关闭
        print('Program terminated')
        # 关闭ListenerThread对象
        listener_thread.is_running = False
        listener_thread.join()
    finally:
        # 关闭ListenerThread对象
        listener_thread.is_running = False
        listener_thread.join()

C++模型调用

此处涉及其他人员写的代码,做修改处理

typedef struct 
{
int width[CV_MAX_BATCH_SIZE];
int height[CV_MAX_BATCH_SIZE];
char* frame[CV_MAX_BATCH_SIZE]; 
int frame_num[CV_MAX_BATCH_SIZE]; 
}PythonMat;

// 多线程控制相关
mutex mtxQueueDet;  // mutex for detect queue
mutex mtxQueueImg;  // mutex for image queue
mutex mtxQueueCls;  // mutex for classify queue
mutex mtxif;
queue<> queueDetOut;// Det output queue
queue<> queueClsOut;// Det classify queue
queue<cv::Mat> queueMat;
bool DetectFlag = true;
bool ClassifyFlag = true;
bool empty_flag = false;

void receiveImg(PythonMat &img)
{
    cv::Mat frame(img.height[0], img.width[0], CV_8UC3, img.frame[0]);

    mtxQueueImg.lock();
    queueMat.push(frame);
    cout << "frame num: "<<  img.frame_num[0] << endl;
    mtxQueueImg.unlock();
}

void DetectImage()
{
    Detect detect_output;
    Detect detectmodel;
    detectmodel.Init(config_path, 1);
    cv::Mat frame;
    while(1)
        { 
            if (queueMat.empty()) 
            {
                if(!DetectFlag)
                {
                    break;
                }
                usleep(2000);
                continue;
            }
            mtxQueueImg.lock();
            frame = queueMat.front();
            queueMat.pop();
            mtxQueueImg.unlock();

            detect_output = detectmodel.Run(detect_input);
            
            // lock
            mtxQueueDet.lock();
            queueDetOut.push(detect_output);
            cout << "detect run !!" << endl;
            mtxQueueDet.unlock();
        }
    return;
}

void ClassifyImage()
{
    Classify objclassify;
    objclassify.Init(config_path, 1);
    ClassifyInput input;
    ClassifyOutput output;
    cv::Mat frame;
    while(1)
    {
        if (queueDetOut.empty()) 
        {
            if(!ClassifyFlag)
            {
                break;
            }
			usleep(2000);
            continue;
		}
        
        mtxQueueDet.lock();
        detect_result = queueDetOut.front();
        queueDetOut.pop();
        mtxQueueDet.unlock();
        
        output = objclassify.Run(input);
        
        mtxQueueCls.lock();
        queueClsOut.push(output);
        mtxQueueCls.unlock();
    }
    return;
}


ClassifyOutput getClsQueue(){
    ObjClassifyOutput output;
    if (queueClsOut.empty()){
        usleep(2000);
        output.object_list.object_num = -1;  // -1 is now empty; -2 is all empty 
        if (empty_flag){
            output.object_list.object_num = -2;
            empty_flag = false;
        }
        return output;
    }
    mtxQueueCls.lock();
    output = queueClsOut.front();
    queueClsOut.pop();
    cout << "cls_out pop " << output.object_list.object_num << endl;
    mtxQueueCls.unlock();
    return output;
    
}

extern "C" {
int i = 0;
void interface_initDetectImage(){
    // if (flag ) exit thread detect/classify 
    DetectImage();
}
void interface_initClassifyImage(){
    ClassifyImage();
}
void interface_receive(PythonMat &img){
    printf("run %d times\n", i++);
    receiveImg(img); 
}
void interface_setEmptyFlag(){
    empty_flag = true;
}
void testThread(){
    printf("C++ method!!\n");
}
ClassifyOutput interface_getClsQueue(){
    ClassifyOutput output;
    output = getClsQueue();
    return output;
}

void interface_destoryThread(){
    DetectFlag = false;
    ClassifyFlag = false;
}
}

至此这个混合编程项目结束,但是server接收到client耗时居然300ms,需要优化…

参考博客

  1. 共享内存
  2. Address already in use
  3. connection-reset-by-peer 我是把client.close()加上就不报错
  4. (最终版)linux下python和c++相互调用共享内存通信
  5. 常见python通信错误
    1. EOFError
    2. OSError: handle is closed
    3. Broken pipe
pybind11混合编程合规性验证:从内存安全到多线程的实战指南 在C++与Python混合编程中,通过pybind11等工具进行接口绑定是提升性能的常见手段。其核心原理在于实现两种语言间对象模型与内存管理的无缝转换。这项技术的价值在于能让Python生态便捷调用高性能C++代码,广泛应用于机器学习、科学计算和高频交易等场景。然而,这种便利性背后潜藏着内存泄漏、类型转换错误和线程安全等深层次隐患,尤其在处理复杂对象生命周期和全局解释器锁(GIL)时问题频发。为确保模块在生产环境中的稳定性,必须建立系统的合规验证体系,针对**内存与生命周期管理**、**类型系统契约**等关 阅读详情

相关推荐

C#与Halcon混合编程避坑指南:内存管理、多线程与性能优化实战

在工业自动化与机器视觉领域,C#因其高效的开发效率和.NET生态的丰富性,常被用于构建上位机软件。而Halcon作为业界领先的机器视觉算法库,提供了强大的图像处理能力。两者结合时,核心挑战在于托管代码与非托管资源的高效协同。其原理涉及.NET垃圾回收机制与Halcon底层C++引擎的内存管理差异,关键在于理解Halcon对象作为非托管资源的包装器本质。这一协同的技术价值在于,能够构建出既具备快速开发迭代能力,又拥有强大、稳定视觉处理核心的工业级应用。典型的应用场景包括视觉检测、定位、测量等系统。本文聚焦于两

weixin_34199764的博客 348

OpenCV-Python cv2.imdecode()和cv2.imencode() 图片解码和编码

cv2.imdecode()函数从指定的内存缓存中读取数据,并把数据转换(解码)成图像格式;主要用于从网络传输数据中恢复出图像。 cv2.imencode()函数是将图片格式转换(编码)成流数据,赋值到内存缓存中;主要用于图像数据格式的压缩,方便网络传输。 imdecode()使用 从网络读取图像数据并转换成图片格式: # -*- coding: utf-8 -*- import num...

云中寻雾的博客 9273

从‘能看’到‘好看’:用Seaborn调色板让你的热力图在PPT和论文中脱颖而出

本文探讨如何利用Seaborn调色板提升热力图在PPT和论文中的视觉效果,从视觉心理学和场景适配角度出发,提供学术与商业场景下的配色方案和实战代码。通过优化色彩选择,使数据可视化更具专业性和吸引力,帮助读者快速理解关键信息。

weixin_30755393的博客 250

【cv2.imread】与【cv2.imdecode】用法

对于路径中含有中文的图像,直接用cv2.imread读取会报错,上次看到有大佬使用cv2.imdecode就可以正常读取,有点好奇,所以今天来记录下二者用法和区别。

向上生长的程序媛的博客 1万+

adb 通信协议分析以及实现 (三) (Adb 网络通信部分解析)

这篇文章说下adb 和adb 服务进程之间通信的socket 协议。  adb 服务进程启动之后,会监视本地的5037 端口,使用的是TCP 协议,所以adb 发送的命令其实就是往本地的5037 端口发送数据,做过网络编程的都知道,本机可以用127.0.0.1 ip地址。 有了ip 地址和端口号socket 通信就没问题 1)  命令发送方式      

inforecovvery的博客 2871

Matlab实战:用递归最小二乘法(RLS)搞定动态系统参数辨识(附完整代码)

本文通过Matlab实战,详细介绍了如何利用递归最小二乘法(RLS)进行动态系统参数辨识。文章从理论优势切入,提供了完整的仿真数据生成、RLS算法核心实现代码,并对参数收敛过程、预测误差及不同遗忘因子的影响进行了可视化分析与性能评估,为工程实践提供了清晰的指南。

weixin_29035405的博客 506

C++多线程多进程服务器muduo函数查询表(一)

本文记录下本人在写服务器过程中遇到的一些相关函数,其具体详解参考给定的参考网址,本文只是做个记录,便于以后再次查询相关函数: 1.(setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)) == -1) 允许重用地址!!!消除bind时"Address already in us...

weixin_38428439的博客 440

基于Android平台下的健康管理APP/基于android的健康管理系统

随着网络科技的发展,移动智能终端逐渐走进人们的视线,相关应用越来越广泛,并在人们的日常生活中扮演着越来越重要的角色。因此,关键应用程序的开发成为影响移动智能终端普及的重要因素,设计并开发实用、方便的应用程序具有重要的意义和良好的市场前景。Android技术作为当前最流行的操作平台,自然也存在着大量的应用服务需求。 本课题研究的是基于Android技术平台的健康管理APP,开发这款健康管理APP主要是为了帮助用户可以不用约束时间与地点进行所需信息。本文详细讲述了健康管理APP的界面设计及使用,主要包括界面的

m0_73706453的博客 1440

python多线程调用视频流进行模型处理后播放

代码如下 fire.py import time import multiprocessing as mp import threading import cv2 from PIL import Image import base64 import json from io import BytesIO import numpy as np import requests """ Source: Yonv1943 2018-06-17 https://github.com/Yonv1943/Python

GeekPlusA的博客 2177

YOLOv8/v9轻量化优化:剪枝30%+蒸馏提精,模型体积缩至4MB还能跑Jetson

剪枝:用敏感度分析找到“可牺牲的30%”,不碰核心特征;蒸馏:借大模型的“经验”补回精度,甚至反超原始小模型;量化:针对边缘设备特性优化量化策略,把体积和延迟压到最低。如果你的项目卡在边缘部署(速度慢/体积大),按“剪枝→蒸馏→量化”三步走,90%能在Jetson上跑通30FPS+的实时检测。需要轻量化模型文件(v8s/v9s剪枝蒸馏后权重)、剪枝工具和Jetson部署脚本的,评论区扣“轻量化”,直接发你可运行版本~

专注于Python爬虫开发,分享爬虫技巧、项目实战与反爬经验,使用Scrapy、BeautifulSoup等工具,解决数据抓取难题。 671

2023华为od机试C卷【最富裕的小家庭】Java&Go 实现

在一颗树中,每个节点代表一个家庭成员,节点的数字表示其个人的财富值,一个节点及其直接相连的子节点被定义为个小家庭。现给你一颗树,请计算出最富裕的小家庭的财富和。

MISAYAONE的博客 1906

c/c++多线程编程与无锁数据结构漫谈

本文主要针对c/c++,系统主要针对linux。本文引述别人的资料均在引述段落加以声明。

songtzu的专栏 3885

1️⃣ Coze智能体基础入门教学(2025年全新版本)

不妨设想一下,倘若我们能够打造出一个数字助手,它不但能精准洞悉我们的需求,更可以独立思索、学习以及付诸行动,这便是 AI Agent 的基础理念。它恰似计算机世界里的 “智慧精灵”,能够感知周遭环境、做出判断并采取行动。AI Agent 的发展之路精彩纷呈。它走过了三个重要阶段:起初,它犹如一个被规则束缚的机器人,只能按预设好的指令开展工作。接着,它学会运用统计学方法,通过分析数据来做决策,变得越发灵活。到如今,凭借深度学习技术,它已经能够像人类一样去学习复杂的任务了。

李同学Lino的博客 4093

QT中C/C++混合编程 openMP多线程遇到的坑

这几天有个项目需要写个界面,由于前期的代码是用C写的,因此毅然决定使用QT来做个界面。 背景: 原始后端程序使用纯C语言编写 程序中使用了openMP多线程加速 QT原生为C++编程,因此就成了C/C++混合编程 编译器使用的MinGW(gcc–5.3.0),支持openMP 在QT中,如果要使用openMP进行加速,需要再pro文件中加入(MinGW gcc版本的): /* 注意,下面这个f...

longzhen1825的博客 1642

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

Python多线程与异步IO混合编程实践:解决“There is no current event loop“问题

方案适用场景优点缺点纯同步(requests)低并发、简单场景代码简单性能差异步+多线程高并发网络请求高性能需管理事件循环多进程CPU密集型+高IO混合任务绕过GIL进程开销大优先使用同步代码(除非性能瓶颈明确)异步+多线程适合高并发HTTP请求Java的异步方案更优雅(推荐通过合理选择方案,可以避免错误,并构建高性能的并发应用。

私聊前往站内信:https://i.youkuaiyun.com/#/msg/chat/weixin_44976692 1万+

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

asyncio 混合编程:多线程和多进程的正确打开方式

需求方案关键 API多个独立的事件循环asyncio + 多线程CPU 密集型计算asyncio + 多进程IO 密集型任务纯 asynciogather()asyncio + 多线程:多事件循环架构,适合隔离业务模块asyncio + 多进程:突破 GIL,适合 CPU 密集型计算核心思想:让异步代码无缝整合同步世界,既保留异步的高效,又解决单线程的瓶颈。

workind的博客 1050

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

第13课:asyncio|多线程|多进程混合编程实战

本课程深入探讨Python中异步编程(asyncio)、多线程与多进程的混合应用场景,旨在解决高并发、计算密集型及I/O密集型任务的性能优化问题。通过实际案例演示如何结合三者优势,规避全局解释器锁(GIL)限制,提升程序效率。asyncio适用于高并发I/O操作,通过事件循环和非阻塞调用实现轻量级并发;多线程适合处理I/O密集型任务,但需注意线程安全;多进程则绕过GIL,充分利用多核CPU处理计算密集型任务。

Java 后端|Python|AI 实战博主。专注微服务、分布式、大模型应用开发,输出可落地项目、源码剖析与面试总结。用通俗文字拆解技术难点,记录开发路上的学习与踩坑,期待和大家一起交流成长。 697

多线程nxtimer定时器改单线程uv_timer定时器 C C++混合编程

这段代码实现了从nxtimer到uv_timer定时器的转换,并处理了C/C++混合编程的问题。核心功能是实现单线程定时器。 主要修改点包括: 将nxtimer替换为libuv的uv_timer_t,避免多线程问题 使用C++类封装定时器逻辑(BrightnessTimer) 通过extern "C"提供C语言兼容接口 使用智能指针管理定时器资源 实现了状态管理函数供C代码调用 定时器逻辑被封装在BrightnessTimer类中,通过handleTou

Obamaaaa的博客 349

C++和QML混合编程_C++端后台多线程处理

C++和QML混合编程_C++端后台多线程处理

会选科技的博客 719

matlab与C语言混合编程之openmp多线程

作为非MATLAB控,却选择MATLAB进行项目的研究,主要还是因为MATLAB使用起来实在太方便了。因此,它的缺陷也很明显,效率不高。内部定义的任何函数,如果我们使用C语言重写,效率一般都能得到一定的提升。     而对于复杂度更高的算法,则需要进一步使用并行编程的方法,比如多线程。那么,在我们使用MATLAB进行项目的主体框架设计后,如何调用使用C语言编写的代码呢?首先,C语言程序肯定需

海之蓝 4545

MPI与多线程(如OpenMP)混合编程注意事项与性能优化

通过合理结合MPI的进程级并行和OpenMP的线程级并行,可以充分利用现代集群的计算资源,实现更高的并行效率和更好的性能扩展性。

weixin_42849849的博客 1861

【C++ 与Qt 线程】C++ std::thread 与Qt qthread多线程混合编程

C++与Qt深度融合:高效设计多线程应用框架

探索C++编程的奥秘,分享深入的技术见解和实践,旨在激发读者创造力与解决问题的思维。 5365

鸿蒙跨端开发:ArkTS与Java混合编程的性能边界测试

鸿蒙操作系统(HarmonyOS)由华为开发,是一款面向全场景、多终端的分布式操作系统。其目标是实现不同设备间的无缝连接和协同工作,包括手机、平板、智能电视、智能穿戴设备等。与传统的Android或iOS不同,鸿蒙采用了一种分布式架构,允许开发者在多个终端之间共享和同步数据。??在鸿蒙跨端开发中,ArkTS与Java的混合编程模式为开发者提供了更高效、灵活的开发方案。通过合理的性能测试与优化,可以确保应用在不同平台上的高效运行,满足用户日益增长的需求。??

xxx_0147的博客 928

《Python实战进阶》No42: 多线程与多进程编程详解(下)

本文将提供多线程和多进程协同实战案例,切实提高并发编程的能力!!!在Python中,多线程与多进程是实现并发编程的核心技术。本集聚焦两者的底层原理与实战差异,结合AI大模型场景(如数据预处理与分布式训练),演示如何通过混合编程提升性能。我们将通过真实代码案例,对比多线程与多进程在图像处理任务中的效率,并探讨如何规避GIL的限制。

yweng18的博客 1544

【python3】多进程与多线程的混合编程

【代码】【python3】多进程与多线程的混合编程。

言之。 1万+
上一篇: python 与python通信、python调用c++ 动态库返回检测结果
下一篇: 混合编程python与C++
AlexNett
博客等级 码龄9年 562粉丝 40原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值