`
anson_xu
  • 浏览: 514609 次
  • 性别: Icon_minigender_1
  • 来自: 惠州
社区版块
存档分类

C++多线程入门(一)

 
阅读更多

第1节   背景
为了更好的理解多线程的概念,先对进程,线程的概念背景做一下简单介绍。

早期的计算机系统都只允许一个程序独占系统资源,一次只能执行一个程序。在大型机年代,计算能力是一种 宝贵资源。对于资源拥有方来说,最好的生财之道自然是将同一资源同时租售给尽可能多的用户。最理想的情况是垄断全球计算市场。所以不难理解为何当年IBM 预测“全球只要有4台计算机就够了”。

这种背景下,一个计算机能够支持多个程序并发执行的需求变得十分迫切。由此产生了进程的概念。进程在多 数早期多任务操作系统中是执行工作的基本单元。进程是包含程序指令和相关资源的集合。每个进程和其他进程一起参与调度,竞争CPU,内存等系统资源。每次 进程切换,都存在进程资源的保存和恢复动作,这称为上下文切换。

进程的引入可以解决支持多用户的问题,但是多进程系统也在如下方面产生了新的问题:
      进程频繁切换引起的额外开销可能会严重影响系统性能。
      进程间通信要求复杂的系统级实现。

在程序功能日趋复杂的情况下,上述缺陷也就凸现出来。比如,一个简单的GUI程序,为了有更好的交互 性,通常用一个任务支持界面交互,另一个任务支持后台运算。如果每个任务均由一个进程来实现,那会相当低效。对每个进程来说,系统资源看上去都是其独占 的。比如内存空间,每个进程认为自己的内存空间是独有的。一次切换,这些独立资源都需要切换。

由此就演化出了利用分配给同一个进程的资源,尽量实现多个任务的方法。这也就引入了线程的概念。同一个进程内部的多个线程,共享的是同一个进程的所有资源。

比如,与每个进程独有自己的内存空间不同,同属一个进程的多个线程共享该进程的内存空间。例如在进程地址空间中有一个全局变量globalVar,若A线程将其赋值为1,则另一线程B可以看到该变量值为1。两个线程看到的全局变量globalVar是同一个变量。

通过线程可以支持同一个应用程序内部的并发,免去了进程频繁切换的开销,另外并发任务间通信也更简单。

目前多线程应用主要用于两大领域:网络应用和嵌入式应用。为什么在这两个领域应用较多呢因为多线程应用能够解决两大问题:
      并发。网络程序具有天生的并发性。比如网络数据库可能需要同时处理数以千计的请求。而由于网络连接的时延不确定性和不可靠性,一旦等待一次网络交互,可以让当前线程进入睡眠,退出调度,处理其他线程。这样就能够有效利用系统资源,充分发挥系统处理能力。
      实时。线程的切换是轻量级的,所以可以保证足够快。每当有事件发生,状态改变,都能有线程及时响应,而且每次线程内部处理的计算强度和复杂度都不大。在这种情况下,多线程实现的模型也是高效的。

在有些语言中,对多线程或者并发的支持是直接内建在语言中的,比如Ada和VHDL。在C++里面,对多线程的支持由具体操作系统提供的函数接口支持。不同的系统中具体实现方法不同。后面所有例子只给出windows和Unix/Linux的实现。

在后面的实现中,考虑的是尽量封装隔离底层的多线程函数接口,屏蔽操作系统底层的线程实现具体细节,介绍的重点是多线程编程中较通用的概念。同时也尽量体现C++面向对象的一面。

最后,由于空闲时间有限,我只求示例代码能够明确表达自己的意思即可。至于代码的尽善尽美就只能有劳各位尽力以为之了。


第2节   线程的创建
本节介绍如下内容
      线程状态
      线程运行环境
      线程类定义
      示例程序
      线程类的Windows和Unix实现
线程状态
在一个线程的生存期内,可以在多种状态之间转换。不同操作系统可以实现不同的线程模型,定义许多不同的线程状态,每个状态还可以包含多个子状态。但大体说来,如下几种状态是通用的:
      就绪:参与调度,等待被执行。一旦被调度选中,立即开始执行。
      运行:占用CPU,正在运行中。
      休眠:暂不参与调度,等待特定事件发生。
      中止:已经运行完毕,等待回收线程资源(要注意,这个很容易误解,后面解释)。
线程环境
线程存在于进程之中。进程内所有全局资源对于内部每个线程均是可见的。
进程内典型全局资源有如下几种:
      代码区。这意味着当前进程空间内所有可见的函数代码,对于每个线程来说也是可见的。
      静态存储区。全局变量。静态变量。
      动态存储区。也就是堆空间。
线程内典型的局部资源有:
      本地栈空间。存放本线程的函数调用栈,函数内部的局部变量等。
      部分寄存器变量。例如本线程下一步要执行代码的指针偏移量。

一个进程发起之后,会首先生成一个缺省的线程,通常称这个线程为主线程。C/C++程序中主线程就是通过main函数进入的线程。由主线程衍生的线程称为从线程,从线程也可以有自己的入口函数,作用相当于主线程的main函数。

这个函数由用户指定。Pthread和winapi中都是通过传入函数指针实现。在指定线程入口函数 时,也可以指定入口函数的参数。就像main函数有固定的格式要求一样,线程的入口函数一般也有固定的格式要求,参数通常都是void *类型,返回类型在pthread中是void *, winapi中是unsigned int,而且都需要是全局函数。

最常见的线程模型中,除主线程较为特殊之外,其他线程一旦被创建,相互之间就是对等关系 (peer to peer), 不存在隐含的层次关系。每个进程可以创建的最大线程数由具体实现决定。

为了更好的理解上述概念,下面通过具体代码来详细说明。
线程类接口定义
一个线程类无论具体执行什么任务,其基本的共性无非就是
      创建并启动线程
      停止线程
      另外还有就是能睡,能等,能分离执行(有点拗口,后面再解释)。
      还有其他的可以继续加…
将线程的概念加以抽象,可以为其定义如下的类:
文件 thread.h

01 <font face= "Verdana" >#ifndef __THREAD__H_
02 #define __THREAD__H_
03 class Thread
04 {
05 public :
06    Thread();
07    virtual ~Thread();
08    int start ( void * = NULL);
09    void stop();
10    void sleep ( int );
11    void detach();
12    void * wait();
13 protected :
14    virtual void * run( void *) = 0;
15 private :
16 //这部分win和unix略有不同,先不定义,后面再分别实现。
17 //顺便提一下,我很不习惯写中文注释,这里为了更明白一
18 //点还是选用中文。
19    … 
20 };
21 #endif</font>

Thread::start()函数是线程启动函数,其输入参数是无类型指针。
Thread::stop()函数中止当前线程。
Thread::sleep()函数让当前线程休眠给定时间,单位为秒。
Thread::run()函数是用于实现线程类的线程函数调用。
Thread::detach()和thread::wait()函数涉及的概念略复杂一些。在稍后再做解释。

Thread类是一个虚基类,派生类可以重载自己的线程函数。下面是一个例子。

示例程序

代码写的都不够精致,暴力类型转换比较多,欢迎有闲阶级美化,谢过了先。
文件create.h

01 <font face= "Verdana" >#ifndef __CREATOR__H_
02 #define __CREATOR__H_
03  
04 #include <stdio.h>
05 #include "thread.h"
06  
07 class Create: public Thread
08 {
09 protected :
10    void * run( void * param)
11    {
12      char * msg = ( char *) param;
13      printf ( "%s\n" , msg);
14      //sleep(100); 可以试着取消这行注释,看看结果有什么不同。
15      printf ( "One day past.\n" );
16      return NULL;
17    }
18 };
19 #endif
20 </font>


然后,实现一个main函数,来看看具体效果:
文件Genesis.cpp

01 <font face= "Verdana" >#include <stdio.h>
02 #include "create.h"
03  
04 int main( int argc, char ** argv)
05 {
06    Create monday;
07    Create tuesday;
08     
09    printf ( "At the first God made the heaven and the earth.\n" );
10    monday.start( "Naming the light, Day, and the dark, Night, the first day." );
11    tuesday.start( "Gave the arch the name of Heaven, the second day." );
12    printf ( "These are the generations of the heaven and the earth.\n" );
13  
14    return 0;
15 }</font>


编译运行,程序输出如下:
At the first God made the heaven and the earth.
These are the generations of the heaven and the earth.
令人惊奇的是,由周一和周二对象创建的子线程似乎并没有执行!这是为什么呢别急,在最后的printf语句之前加上如下语句:
monday.wait();
tuesday.wait();
重新编译运行,新的输出如下:
At the first God made the heaven and the earth.
Naming the light, Day, and the dark, Night, the first day.
One day past.
Gave the arch the name of Heaven, the second day.
One day past.
These are the generations of the heaven and the earth.

为了说明这个问题,需要了解前面没有解释的Thread::detach()和Thread::wait()两个函数的含义。

无论在windows中,还是Posix中,主线程和子线程的默认关系是:
无论子线程执行完毕 与否,一旦主线程执行完毕退出,所有子线程执行都会终止。这时整个进程结束或僵死(部分线程保持一种终止执行但还未销毁的状态,而进程必须在其所有线程销 毁后销毁,这时进程处于僵死状态),在第一个例子的输出中,可以看到子线程还来不及执行完毕,主线程的main()函数就已经执行完毕,从而所有子线程终 止。

需要强调的是,线程函数执行完毕退出,或以其他非常方式终止,线程进入终止态(请回顾上面说的线程状 态),但千万要记住的是,进入终止态后,为线程分配的系统资源并不一定已经释放,而且可能在系统重启之前,一直都不能释放。终止态的线程,仍旧作为一个线 程实体存在与操作系统中。(这点在win和unix中是一致的。)而什么时候销毁线程,取决于线程属性。

通常,这种终止方式并非我们所期望的结果,而且一个潜在的问题是未执行完就终止的子线程,除了作为线程 实体占用系统资源之外,其线程函数所拥有的资源(申请的动态内存,打开的文件,打开的网络端口等)也不一定能释放。所以,针对这个问题,主线程和子线程之 间通常定义两种关系:
      可会合(joinable)。这种关系下,主线程需要明确执行等待操作。在子线程结束后,主线程的等待操作执行完毕,子线程和主线程会合。这时主线程继续 执行等待操作之后的下一步操作。主线程必须会合可会合的子线程,Thread类中,这个操作通过在主线程的线程函数内部调用子线程对象的wait()函数 实现。这也就是上面加上三个wait()调用后显示正确的原因。必须强调的是,即使子线程能够在主线程之前执行完毕,进入终止态,也必需显示执行会合操 作,否则,系统永远不会主动销毁线程,分配给该线程的系统资源(线程id或句柄,线程管理相关的系统资源)也永远不会释放。
      相分离(detached)。顾名思义,这表示子线程无需和主线程会合,也就是相分离的。这种情况下,子线程一旦进入终止态,系统立即销毁线程,回收资 源。无需在主线程内调用wait()实现会合。Thread类中,调用detach()使线程进入detached状态。这种方式常用在线程数较多的情 况,有时让主线程逐个等待子线程结束,或者让主线程安排每个子线程结束的等待顺序,是很困难或者不可能的。所以在并发子线程较多的情况下,这种方式也会经 常使用。
缺省情况下,创建的线程都是可会合的。可会合的线程可以通过调用detach()方法变成相分离的线程。但反向则不行。

UNIX实现

文件 thread.h

001 <font face= "Verdana" >#ifndef __THREAD__H_
002 #define __THREAD__H_
003 class Thread
004 {
005 public :
006    Thread();
007    virtual ~Thread();
008    int start ( void * = NULL);
009    void stop();
010    void sleep ( int );
011    void detach();
012    void * wait();
013 protected :
014    virtual void * run( void *) = 0;
015 private :
016    pthread_t handle;
017    bool started;
018    bool detached;
019    void * threadFuncParam;
020 friend void * threadFunc( void *);
021 };
022  
023 //pthread中线程函数必须是一个全局函数,为了解决这个问题
024 //将其声明为静态,以防止此文件之外的代码直接调用这个函数。
025 //此处实现采用了称为Virtual friend function idiom 的方法。
026 Static void * threadFunc( void *);
027 #endif
028  
029 文件 thread .cpp
030 #include <pthread.h>
031 #include <sys/time.h>
032 #include “thread.h”
033  
034 static void * threadFunc ( void * threadObject)
035 {
036    Thread * thread = (Thread *) threadObject;
037    return thread ->run( thread ->threadFuncParam);
038 }
039  
040 Thread::Thread()
041 {
042    started = detached = false ;
043 }
044  
045 Thread::~Thread()
046 {
047    stop();
048 }
049  
050 bool Thread::start( void * param)
051 {
052    pthread_attr_t attributes;
053    pthread_attr_init(&attributes);
054    if (detached)
055    {
056      pthread_attr_setdetachstate(&attributes, PTHREAD_CREATE_DETACHED);
057    }
058  
059    threadFuncParam = param;
060  
061    if (pthread_create(&handle, &attributes, threadFunc, this ) == 0)
062    {
063      started = true ;
064    }
065  
066    pthread_attr_destroy(&attribute);
067 }
068  
069  
070 void Thread::detach()
071 {
072    if (started && !detached)
073    {
074      pthread_detach(handle);
075    }
076    detached = true ;
077 }
078  
079 void * Thread::wait()
080 {
081    void * status = NULL;
082    if (started && !detached)
083    {
084      pthread_join(handle, &status);
085    }
086    return status;
087 }
088  
089 void Thread::stop()
090 {
091    if (started && !detached)
092    {
093      pthread_cancel(handle);
094      pthread_detach(handle);
095      detached = true ;
096    }
097 }
098  
099 void Thread::sleep(unsigned int milliSeconds)
100 {
101    timeval timeout = { milliSeconds/1000, millisecond%1000};
102    select(0, NULL, NULL, NULL, &timeout);
103 }</font>


Windows实现

文件thread.h

001 <font face= "Verdana" >#ifndef _THREAD_SPECIFICAL_H__
002 #define _THREAD_SPECIFICAL_H__
003  
004 #include <windows.h>
005  
006 static unsigned int __stdcall threadFunction( void *);
007  
008 class Thread {
009          friend unsigned int __stdcall threadFunction( void *);
010 public :
011          Thread();
012          virtual ~Thread();
013          int start( void * = NULL);
014          void * wait();
015          void stop();
016          void detach();
017          static void sleep(unsigned int );
018  
019 protected :
020          virtual void * run( void *) = 0;
021  
022 private :
023          HANDLE threadHandle;
024          bool started;
025          bool detached;
026          void * param;
027          unsigned int threadID;
028 };
029  
030 #endif
031  
032 文件 thread .cpp
033 #include "stdafx.h"
034 #include <process.h>
035 #include "thread.h"
036  
037 unsigned int __stdcall threadFunction( void * object)
038 {
039          Thread * thread = (Thread *) object;
040          return   (unsigned int ) thread ->run( thread ->param);
041 }
042  
043 Thread::Thread()
044 {
045          started = false ;
046          detached = false ;
047 }
048  
049 Thread::~Thread()
050 {
051          stop();
052 }
053  
054 int Thread::start( void * pra)
055 {
056          if (!started)
057          {
058                  param = pra;
059                  if (threadHandle = ( HANDLE )_beginthreadex(NULL, 0, threadFunction, this , 0, &threadID))
060                  {
061                          if (detached)
062                          {
063                                  CloseHandle(threadHandle);
064                          }
065                          started = true ;
066                  }
067          }
068          return started;
069 }
070  
071 //wait for current thread to end.
072 void * Thread::wait()
073 {
074          DWORD status = ( DWORD ) NULL;
075          if (started && !detached)
076          {
077                  WaitForSingleObject(threadHandle, INFINITE);
078                  GetExitCodeThread(threadHandle, &status);      
079                  CloseHandle(threadHandle);
080                  detached = true ;
081          }
082  
083          return ( void *)status;
084 }
085  
086 void Thread::detach()
087 {
088    if (started && !detached)
089    {
090      CloseHandle(threadHandle);
091    }
092    detached = true ;
093 }
094  
095 void Thread::stop()
096 {
097          if (started && !detached)
098          {
099                  TerminateThread(threadHandle, 0);
100  
101                  //Closing a thread handle does not terminate
102                  //the associated thread.
103                  //To remove a thread object, you must terminate the thread,
104                  //then close all handles to the thread.
105                  //The thread object remains in the system until
106                  //the thread has terminated and all handles to it have been
107                  //closed through a call to CloseHandle
108                  CloseHandle(threadHandle);
109                  detached = true ;
110          }
111 }
112  
113 void Thread::sleep(unsigned int delay)
114 {
115          ::Sleep(delay);
116 }
117 </font>


小结

本节的主要目的是帮助入门者建立基本的线程概念,以此为基础,抽象出一个最小接口的通用线程类。在示例 程序部分,初学者可以体会到并行和串行程序执行的差异。有兴趣的话,大家可以在现有线程类的基础上,做进一步的扩展和尝试。如果觉得对线程的概念需要进一 步细化,大家可以进一步扩展和完善现有Thread类。

想更进一步了解的话,一个建议是,可以去看看其他语言,其他平台的线程库中,线程类抽象了哪些概念。比 如Java, perl等跨平台语言中是如何定义的,微软从winapi到dotnet中是如何支持多线程的,其线程类是如何定义的。这样有助于更好的理解线程的模型和 基础概念。

另外,也鼓励大家多动手写写代码,在此基础上尝试写一些代码,也会有助于更好的理解多线程程序的特点。比如,先开始的线程不一定先结束。线程的执行可能会交替进行。把printf替换为cout可能会有新的发现,等等。

每个子线程一旦被创建,就被赋予了自己的生命。管理不好的话,一只特例独行的猪是非常让人头痛的。

对于初学者而言,编写多线程程序可能会遇到很多令人手足无措的bug。往往还没到考虑效率,避免死锁等阶段就问题百出,而且很难理解和调试。这是非常正常的,请不要气馁,后续文章会尽量解释各种常见问题的原因,引导大家避免常见错误。目前能想到入门阶段常遇到的问题是:
      内存泄漏,系统资源泄漏。
      程序执行结果混乱,但是在某些点插入sleep语句后结果又正确了。
      程序crash, 但移除或添加部分无关语句后,整个程序正常运行(假相)。
      多线程程序执行结果完全不合逻辑,出于预期。

本文至此,如果自己动手改改,试一些例子,对多线程程序应该多少有一些感性认识了。刚开始只要把基本概念弄懂了,后面可以一步一步搭建出很复杂的类。不过刚开始不要贪多,否则会欲速则不达,越弄越糊涂。

最后,大家见仁见智吧,我在此起到抛砖引玉的作用就很开心了,呵呵。另外文本编辑器的原因,代码如果编译不过,可能需要把标点符号从中文换成英文。

分享到:
评论

相关推荐

    java毕设项目之ssm基于SSM的高校共享单车管理系统的设计与实现+vue(完整前后端+说明文档+mysql+lw).zip

    项目包含完整前后端源码和数据库文件 环境说明: 开发语言:Java 框架:ssm,mybatis JDK版本:JDK1.8 数据库:mysql 5.7 数据库工具:Navicat11 开发软件:eclipse/idea Maven包:Maven3.3 服务器:tomcat7

    YOLO算法-贴纸检测数据集-212张图像带标签-部分覆盖-未涵盖-完全覆盖.zip

    YOLO系列算法目标检测数据集,包含标签,可以直接训练模型和验证测试,数据集已经划分好,包含数据集配置文件data.yaml,适用yolov5,yolov8,yolov9,yolov7,yolov10,yolo11算法; 包含两种标签格:yolo格式(txt文件)和voc格式(xml文件),分别保存在两个文件夹中,文件名末尾是部分类别名称; yolo格式:<class> <x_center> <y_center> <width> <height>, 其中: <class> 是目标的类别索引(从0开始)。 <x_center> 和 <y_center> 是目标框中心点的x和y坐标,这些坐标是相对于图像宽度和高度的比例值,范围在0到1之间。 <width> 和 <height> 是目标框的宽度和高度,也是相对于图像宽度和高度的比例值; 【注】可以下拉页面,在资源详情处查看标签具体内容;

    zigbee CC2530无线自组网协议栈系统代码实现协调器按键控制终端LED灯和继电器动作.zip

    1、嵌入式物联网单片机项目开发例程,简单、方便、好用,节省开发时间。 2、代码使用IAR软件开发,当前在CC2530上运行,如果是其他型号芯片,请自行移植。 3、软件下载时,请注意接上硬件,并确认烧录器连接正常。 4、有偿指导v:wulianjishu666; 5、如果接入其他传感器,请查看账号发布的其他资料。 6、单片机与模块的接线,在代码当中均有定义,请自行对照。 7、若硬件有差异,请根据自身情况调整代码,程序仅供参考学习。 8、代码有注释说明,请耐心阅读。 9、例程具有一定专业性,非专业人士请谨慎操作。

    手语图像分类数据集【已标注,约2,500张数据】

    手语图像分类数据集【已标注,约2,500张数据】 分类个数【36】:0、1、a、b等【具体查看json文件】 划分了训练集、测试集。存放各自的同一类数据图片。如果想可视化数据集,可以运行资源中的show脚本。 CNN分类网络改进:https://blog.csdn.net/qq_44886601/category_12858320.html 【更多图像分类、图像分割(医学)、目标检测(yolo)的项目以及相应网络的改进,可以参考本人主页:https://blog.csdn.net/qq_44886601/category_12803200.html】

    CNCAP 2024打分表

    CNCAP 2024打分表

    基于小程序的智慧校园管理系统源代码(java+小程序+mysql+LW).zip

    系统可以提供信息显示和相应服务,其管理智慧校园管理系统信息,查看智慧校园管理系统信息,管理智慧校园管理系统。 项目包含完整前后端源码和数据库文件 环境说明: 开发语言:Java JDK版本:JDK1.8 数据库:mysql 5.7 数据库工具:Navicat11 开发软件:eclipse/idea Maven包:Maven3.3 部署容器:tomcat7 小程序开发工具:hbuildx/微信开发者工具

    【图像去噪】基于matlab PolSAR GWLS滤波器图像去噪【含Matlab源码 9937期】.zip

    Matlab领域上传的视频均有对应的完整代码,皆可运行,亲测可用,适合小白; 1、代码压缩包内容 主函数:main.m; 调用函数:其他m文件;无需运行 运行结果效果图; 2、代码运行版本 Matlab 2019b;若运行有误,根据提示修改;若不会,私信博主; 3、运行操作步骤 步骤一:将所有文件放到Matlab的当前文件夹中; 步骤二:双击打开main.m文件; 步骤三:点击运行,等程序运行完得到结果; 4、仿真咨询 如需其他服务,可私信博主; 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作

    影音互动科普网站-JAVA-基于SpringBoot的哈利波特书影音互动科普网站设计与实现(毕业论文)

    影音互动科普网站功能描述 影音互动科普网站旨在通过多媒体形式(视频、音频、互动内容等)传播科学知识,提高公众的科学素养。该网站结合娱乐与教育,提供易于理解的科普内容,吸引不同年龄层次的用户参与和学习。以下是该网站的主要功能描述: 1. 用户注册与登录 用户注册:用户可以通过电子邮箱、手机号或社交账号(如微信、微博等)注册,提供基本信息并设置密码。 用户登录:支持通过注册的账号登录,保障个人信息的安全性,并提供自动登录功能。 2. 科普视频与音频库 视频内容:网站提供各类科普视频,包括短视频、纪录片、讲座、实验演示等,覆盖物理、化学、生物、地理、天文等多个领域。 音频内容:提供科普音频节目,如科普广播、播客、专题讲座等,便于用户在日常生活中进行学习。 视频分类:按科目、难度、年龄层、时长等维度对视频和音频进行分类,帮助用户更精准地找到感兴趣的内容。 字幕与多语言支持:提供字幕、翻译和多语种版本,帮助不同语言的用户学习。 3. 互动问答与讨论区 专家问答:用户可以向科普专家提问,专家提供详尽的解答,解决用户的科学疑惑。 社区讨论:用户可以在视频下方或专题页面中发表评论、提问或与其他用户

    倪海厦讲义及笔记,易学数据测算

    倪海厦讲义及笔记,易学数据测算

    【组合数学答案】组合数学-苏大李凡长版-课后习题答案

    内容概要:本文档是《组合数学答案-网络流传版.pdf》的内容,主要包含了排列组合的基础知识以及一些经典的组合数学题目。这些题目涵盖了从排列数计算、二项式定理的应用到容斥原理的实际应用等方面。通过对这些题目的解析,帮助读者加深对组合数学概念和技巧的理解。 适用人群:适合初学者和有一定基础的学习者。 使用场景及目标:可以在学习组合数学课程时作为练习题参考,也可以在复习考试或准备竞赛时使用,目的是提高解决组合数学问题的能力。 其他说明:文档中的题目覆盖了组合数学的基本知识点,适合逐步深入学习。每个题目都有详细的解答步骤,有助于读者掌握解题思路和方法。

    管理系统开发指南:功能要求、技术栈及安全控制

    内容概要:本文是一篇完整的管理系统开发指南,详细介绍了功能要求、技术栈选择、数据库设计、用户界面搭建以及安全控制等方面的内容。功能要求包括用户管理、权限控制、数据管理、系统日志、通知与消息、统计分析和扩展模块。使用的技术栈涵盖了后端(Java、Python、C#等)和前端(React、Vue.js、Angular等)技术,以及数据库设计和安全控制措施。 适合人群:具备一定开发经验的软件工程师和技术管理人员。 使用场景及目标:适用于企业级管理系统开发项目,旨在构建一个高效、安全且易于扩展的系统。开发者可以参考本文档进行系统的设计和实现,确保系统满足业务需求。 其他说明:本文档提供了详细的步骤和最佳实践,帮助开发者更好地理解和应用管理系统开发的各种技术。通过结合实际案例和实践经验,本文档能够为开发者提供有价值的指导。

    听器听力损伤程度分级表.docx

    听器听力损伤程度分级表.docx

    MATLAB代码:基于条件风险价值的合作型Stackerlberg博弈微网动态定价与优化调度 关键词:微网优化调度 条件风险价值 合作博弈 纳什谈判 参考文档:A cooperative Stack

    MATLAB代码:基于条件风险价值的合作型Stackerlberg博弈微网动态定价与优化调度 关键词:微网优化调度 条件风险价值 合作博弈 纳什谈判 参考文档:《A cooperative Stackelberg game based energy management considering price discrimination and risk assessment》完美复现 仿真平台:MATLAB yalmip+cplex+mosek 主要内容:代码主要做的是一个基于合作型Stackerlberg博弈的考虑差别定价和风险管理的微网动态定价与调度策略,提出了一个双层能源管理框架,实现多个微网间的P2P能源交易,上层为零商的动态定价模型,目标是社会福利最大化;下层是多个产消者的合作博弈模型,优化各产消者的能量管理策略。 同时,采用纳什谈判法对多个产消者的合作剩余进行公平分配,还考虑了运行风险,采用条件风险价值(CVaR)随机规划方法来描述零商的预期损失。 求解方面,双层模型被基于KKT条件转为单层模型,模型可以高效求解。 这段代码是一个基于合作型Stackelberg博弈的微网

    YOLO算法-监控数据集-873张图像带标签-警方-警车-救护车-消防车-跌倒的人-消防员.zip

    YOLO系列算法目标检测数据集,包含标签,可以直接训练模型和验证测试,数据集已经划分好,包含数据集配置文件data.yaml,适用yolov5,yolov8,yolov9,yolov7,yolov10,yolo11算法; 包含两种标签格:yolo格式(txt文件)和voc格式(xml文件),分别保存在两个文件夹中,文件名末尾是部分类别名称; yolo格式:<class> <x_center> <y_center> <width> <height>, 其中: <class> 是目标的类别索引(从0开始)。 <x_center> 和 <y_center> 是目标框中心点的x和y坐标,这些坐标是相对于图像宽度和高度的比例值,范围在0到1之间。 <width> 和 <height> 是目标框的宽度和高度,也是相对于图像宽度和高度的比例值; 【注】可以下拉页面,在资源详情处查看标签具体内容;

    (175526236)【动漫网页设计】源码免费分享,让你的网站更有趣!

    20块钱买的【动漫网页设计】源码,免费分享出来啦,如果要积分那是系统自动涨的啦。 内容概要:本资源是一份动漫网页设计的源码,价格仅为20元,作者将其免费分享给大家。该源码包含了动漫元素的设计,包括背景、图标、按钮等,同时也提供了一些常见的网页布局和交互效果。通过该资源,可以学习到动漫网页设计的基本原理和技巧。 适用人群:本资源适用于对动漫网页设计感兴趣的人群,包括网页设计师、UI设计师、前端开发工程师等。同时,对于想要学习动漫网页设计的初学者也非常适用。 使用场景及目标:该资源可以用于学习和实践动漫网页设计的技巧和原理。通过学习该源码,可以了解到动漫网页设计的基本要素和设计思路,同时也可以借鉴其中的设计元素和交互效果,应用到自己的网页设计中。 其他说明:本资源是作者自己设计的,经过了多次修改和优化,具有一定的参考价值。同时,作者也将其价格设置的非常低,希望更多的人可以学习到动漫网页设计的技巧和方法。如果您对该资源有任何疑问或建议,欢迎在评论区留言,作者会尽快回复。。内容来源于网络分享,如有侵权请联系我删除。另外如果没有积分的同学需要下载,请私信我。

    C++程序设计-参考答案

    自考 本科 C++程序设计-课本 参考答案

    每周质量安全排查报告.docx

    每周质量安全排查报告.docx

    YOLO算法-杂草检测项目数据集-3970张图像带标签-杂草.zip

    YOLO算法-杂草检测项目数据集-3970张图像带标签-杂草.zip

    内存搜索工具(易).rar

    内存搜索工具(易).rar

    2024 AGM Meritech Market Section (External).pdf

    AI大模型研究相关报告

Global site tag (gtag.js) - Google Analytics