C++线程编程解析+事例

最新推荐文章于 2025-03-06 11:48:42 发布
最新推荐文章于 2025-03-06 11:48:42 发布
阅读量981 收藏 1
点赞数 1
分类专栏： C++ 线程 文章标签： c++ 编程 winapi null fun attributes

1：创建线程函数介绍


在window系统中编写控制台程序，创建线程

使用CreateThread()函数创建，则线程函数必须申明为DWORD WINAPI；

使用_beginthreadex()创建，则线程函数必须申明为unsigned int WINAPI;

并需要设置环境：工程->设置->C/C++->Code Generation->Use run-time libray->选 Debug Multithread（多线程），或 Multithread.

将类成员函数作为线程函数方式：

1.将类成员申明为STATIC成员函数；

2.将函数申明为类的友元函数；


   1.1  CreateThread函数

“CreateThread函数是用来创建线程的Windows函数不过，如果你正在编写C/C++代码，决不应该调用CreateThread。相反，应该使用Visual C++运行期库函数_beginthreadex。如果不使用Microsoft的Visual C++编译器，你的编译器供应商有它自己的CreateThred替代函数。不管这个替代函数是什么，你都必须使用。”

HANDLE CreateThread

( LPSECURITY_ATTRIBUTES lpsa,

 DWORD cbStack, 

 LPTHREAD_START_ROUTINE lpStartAddr,

 LPVOID lpvThreadParam,

 DWORD fdwCreate,

 LPDWORD lpIDThread);

具体解释为：

 //第1个参数：lpsa：线程句柄的安全属性，比如子进程是否可以继承这个线程句柄，一般情况设置为NULL

 //第1个参数：cbStack：线程栈大小，一般取0表示默认大小

 //第3个参数：lpStartAddr：线程入口函数

                 typedef DWORD (__stdcall *LPTHREAD_START_ROUTINE) ( void* lpThreadParameter );

                在win32程序中默认的调用函数约定就是WINAPI ，__stdcall = WINAPI 

                因此你可以声明你的入口函数为：DWORD WINAPI ThreadProc( void* lpParamete) {//线程中你要做的事情}

 //第4个参数：lpvThreadParam：就是线程入口函数的参数，就是ThreadProc( void* lpParamete) 的参数

 //第5个参数：fdwCreate：控制线程创建的标志一般为0，表示线程立即启动。如果你想创建之后把线程挂起来可以传入CREATE_SUSPENDED ，传入这个参数你需要再适当的地方调用                              ResumeThread 启动线程

 //第6个参数lpIDThread：是线程ID返回值，这个用来接收线程返回的ID。

   1.2 _beginthreadex()函数

参数说明：

unsigned long _beginthreadex( void *security, unsigned stack_size, unsigned ( __stdcall *start_address )( void * ), void *arglist, unsigned initflag, unsigned *thrdaddr );

 //第1个参数：安全属性，NULL为默认安全属性
 //第2个参数：指定线程堆栈的大小。如果为0，则线程堆栈大小和创建它的线程的相同。一般用0
 //第3个参数：指定线程函数的地址，也就是线程调用执行的函数地址(用函数名称即可，函数名称就表示地址)
 //第4个参数：传递给线程的参数的指针，可以通过传入对象的指针，在线程函数中再转化为对应类的指针
 //第5个参数：线程初始状态，0:立即运行；CREATE_SUSPEND：suspended（悬挂）
 //第6个参数：用于记录线程ID的地址



C运行库_beginthreadex()。他经过一些处理后，再调用CreateThread()，因此比CreateThread安全一些。如果要强制结束的话也最好用_endthreadex 结束，因为他也要一些处理。如果不是调用_endthreadex来终止线程的运行，那么数据块就不会被撤消，内存泄漏就会出现

另外还有AfxBeginThread()

具体区别请参照：http://hi.baidu.com/kings0527/blog/item/11838d02a1b3bbe608fa93ff.html

2：线程创建的例子

以下只是框架 

全局变量  HANDLE g_Thread ;

 在类CA中  

 class CA
{


public :

  int m_member;  //成员变量 
   static WINAPI UINT  threadFunc(LPVOID P)； //必须是静态的 或者全局的 
   

   void OnInitDialog()  

{

 g_Thread = (HANDLE)_beginthreadex(NULL, 0, ThreadFun,this, 0, &threadID);  //this 参数的传递 

if (g_Thread==0)
{
          GetLastError(); 

   .............
            MessageBox(_T("_beginthreadex 创建失败!"));
           _endthread(g_Thread);
        

}

else
MessageBox(_T("_beginthreadex 创建成功!"));

}

UINT threadFunc(LPVOID p)
{
   CA *obj = p;
   obj->m_member ;   //成员变量的传递
}

｝
更好的例子参照：http://blog.youkuaiyun.com/maopig/article/details/6772258   详细的解释  


3：线程的同步
 

    1临界区:通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。

    2互斥量:为协调共同对一个共享资源的单独访问而设计的。

    3信号量:为控制一个具有有限数量用户资源而设计。

    4事 件:用来通知线程有一些事件已发生，从而启动后继任务的开始。


  互斥体代码例子：

   
<pre name="code" class="cpp">//这是2个线程模拟卖火车票的小程序
#include <windows.h>
#include <iostream.h>

DWORD WINAPI Fun1Proc(LPVOID lpParameter);//thread data
DWORD WINAPI Fun2Proc(LPVOID lpParameter);//thread data

int index=0;
int tickets=10;
HANDLE hMutex;
void main()
{
    HANDLE hThread1;
    HANDLE hThread2;
    //创建线程

    hThread1=CreateThread(NULL,0,Fun1Proc,NULL,0,NULL);
    hThread2=CreateThread(NULL,0,Fun2Proc,NULL,0,NULL);
    CloseHandle(hThread1);
    CloseHandle(hThread2);

    //创建互斥对象
    hMutex=CreateMutex(NULL,TRUE,"tickets");
    if (hMutex)
    {
        if (ERROR_ALREADY_EXISTS==GetLastError())//得到错误：已经存在
        {
		// 如果已有互斥量存在则释放句柄并复位互斥量
　		CloseHandle(m_hMutex);
　		m_hMutex = NULL;
            cout<<"only one instance can run!"<<endl;
            return;
        }
    }
    WaitForSingleObject(hMutex,INFINITE);
    ReleaseMutex(hMutex);//申请了两次就要施放两次（没搞懂在哪里申请了两次？难道建立一次，wait也算一次？）
    ReleaseMutex(hMutex);//谁申请谁施放
    
    Sleep(4000);//让主线程睡4秒，让其他线程有时间执行完他们的代码，如果不睡就会出现其他线程执行不完或出错的情况，但时如果不知道线程需要多少时间执行，那应该写多少时间？
}
//线程1的入口函数
DWORD WINAPI Fun1Proc(LPVOID lpParameter)//thread data
{
    while (true)//无限循环线程
    {
        WaitForSingleObject(hMutex,INFINITE);//得到互斥体才能执行
        if (tickets>0)
        {
            Sleep(1);
            cout<<"thread1 sell ticket :"<<tickets--<<endl;
        }
        else
            break;
        ReleaseMutex(hMutex);//施放互斥体
    }

    return 0;
}
//线程2的入口函数
DWORD WINAPI Fun2Proc(LPVOID lpParameter)//thread data
{
    while (true)
    {
        WaitForSingleObject(hMutex,INFINITE);
        if (tickets>0)
        {
            Sleep(1);
            cout<<"thread2 sell ticket :"<<tickets--<<endl;
        }
        else
            break;
        ReleaseMutex(hMutex);
    }
    
    return 0;
}
//详解
HANDLE CreateMutex(
　LPSECURITY_ATTRIBUTES lpMutexAttributes, // 指向安全属性的指针
　BOOL bInitialOwner, // 初始化互斥对象的所有者
　LPCTSTR lpName // 指向互斥对象名的指针
);
参数 
lpMutexAttributes 
指向一个SECURITY_ATTRIBUTES结构的指针，这个结构决定互斥体句柄是否被子进程继承。     
bInitialOwner 
布尔类型，决定互斥体的创建者是否为拥有者 
lpName 
指向互斥体名字字符串的指针。互斥体可以有名字。 
互斥体的好处是可以在进程间共享
http://blog.youkuaiyun.com/goodai007/article/details/6976081
临界区例子： 


 // Global variable
CRITICAL_SECTION CriticalSection; 

void main()
{
...

// Initialize the critical section one time only.
if (!InitializeCriticalSectionAndSpinCount(&CriticalSection, 
0x80000400) ) 
return;
...

// Release resources used by the critical section object.
DeleteCriticalSection(&CriticalSection)
}

DWORD WINAPI ThreadProc( LPVOID lpParameter )
{
...

// Request ownership of the critical section.
EnterCriticalSection(&CriticalSection); 

// Access the shared resource.

// Release ownership of the critical section.
LeaveCriticalSection(&CriticalSection);

...
}
更多例子在：
 VC下线程同步的三种方法(互斥、事件、临界区)
http://blog.youkuaiyun.com/pl2597758/article/details/2507790#

首选使用临界区对象,主要原因是使用简单。 
EnterCriticalSection（）函数等候指定的危险区段对象的所有权。当调用的线程被允许所有权时，函数返回。 
EnterCriticalSection （），一个单独进程的线程可以使用一个危险区段对象作为相互-排除同步。 进程负责分配被一个危险区段对象使用的内存, 它藉由声明一个CRITICAL_SECTION类型 的变量实现。在使用一个危险区段之前，进程的一些线程必须调用 InitializeCriticalSection 函数设定对象的初值.
为了要使互斥的访问被共享的资源,每个线程调用EnterCriticalSection 或者 TryEnterCriticalSection 功能，在执行访问被保护资源的任何代码段之前，请求危险区段的所有权。 
 


#include <windows.h>
#include <iostream>
using namespace std;
DWORD WINAPI Fun1Proc(LPVOID lpParameter);
DWORD WINAPI Fun2Proc(LPVOID lpParameter);
int tickets=100;
CRITICAL_SECTION g_csA;
CRITICAL_SECTION g_csB;
void main()
{
 HANDLE hThread1;
 HANDLE hThread2;
 hThread1=CreateThread(NULL,0,Fun1Proc,NULL,0,NULL);
 hThread2=CreateThread(NULL,0,Fun2Proc,NULL,0,NULL);
 CloseHandle(hThread1);
 CloseHandle(hThread2);
 InitializeCriticalSection(&g_csA);
 InitializeCriticalSection(&g_csB);
 Sleep(40000);
 DeleteCriticalSection(&g_csA);
 DeleteCriticalSection(&g_csB);
}
DWORD WINAPI Fun1Proc(LPVOID lpParameter)
{
 while (TRUE)
 {
  EnterCriticalSection(&g_csA);
  Sleep(1);
  //EnterCriticalSection(&g_csB);//临界区的同步和互锁
  if (tickets>0)
  {
   Sleep(1);
   cout<<"Thread1 sell ticket :"<<tickets--<<endl;
   //LeaveCriticalSection(&g_csB);
   LeaveCriticalSection(&g_csA);
  }
  else
  {
   //LeaveCriticalSection(&g_csB);
   LeaveCriticalSection(&g_csA);
   break;
  }
 }
 return 0;
}
DWORD WINAPI Fun2Proc(LPVOID lpParameter)
{
 while (TRUE)
 {
  EnterCriticalSection(&g_csB);
  Sleep(1);
  EnterCriticalSection(&g_csA);
  if (tickets>0)
  {
   Sleep(1);
   cout<<"Thread2 sell ticket :"<<tickets--<<endl;
   LeaveCriticalSection(&g_csA);
   LeaveCriticalSection(&g_csB);
  }
  else
  {
   LeaveCriticalSection(&g_csA);
   LeaveCriticalSection(&g_csB);
   break;
  }
 }
 return 0;
}

--------------------------------------------------------------------------------
 
二、使用互斥对象
DWORD WaitForSingleObject(HANDLE hHandle, DWORD dwMilliseconds); 
如果时间是有信号状态返回WAIT_OBJECT_0，如果时间超过dwMilliseconds值但时间事件还是无信号状态则返回WAIT_TIMEOUT
WaitForSingleObject函数用来检测hHandle事件的信号状态，当函数的执行时间超过dwMilliseconds就返回，但如果参数dwMilliseconds为INFINITE时函数将直到相应时间事件变成有信号状态才返回，否则就一直等待下去，直到WaitForSingleObject有返回直才执行后面的代码。
#include <windows.h>
#include <iostream>
using namespace std;
DWORD WINAPI Fun1Proc(LPVOID lpParameter);
DWORD WINAPI Fun2Proc(LPVOID lpParameter);
int index =0;
int tickets=100;
HANDLE hMutex;
void main()
{
 HANDLE hThread1;
 HANDLE hThread2;
 //创建线程
 hThread1=CreateThread(NULL,0,Fun1Proc,NULL,0,NULL);
 hThread2=CreateThread(NULL,0,Fun2Proc,NULL,0,NULL);
 CloseHandle(hThread1);
 CloseHandle(hThread2);
 //**************************************************************
 //保证应用程序只有一个实例运行,创建一个命名的互斥对象.
 hMutex=CreateMutex(NULL,TRUE,LPCTSTR("tickets"));
 //创建时主线程拥有该互斥对象,互斥对象的线程ID为主线程的ID,同时将该互斥对象内部计数器置为1
 if (hMutex)
 {
  if (ERROR_ALREADY_EXISTS==GetLastError())
  {
   cout<<"only one instance can run!"<<endl;
   //Sleep(40000);
   return;
  }
 }
 //**************************************************************
 WaitForSingleObject(hMutex,INFINITE);
 //使用该函数请求互斥对象时,虽说该对象处于无信号状态,但因为请求的线程ID和该互斥对象所有者的线程ID是相同的.所以仍然可以请求到这个互斥对象,于是该互斥对象内部计数器加1,内部计数器的值为2. 意思是有两个等待动作
 ReleaseMutex(hMutex);//释放一次互斥对象,该互斥对象内部计数器的值递减1,操作系统不会将这个互斥对象变为已通知状态.
 ReleaseMutex(hMutex);//释放一次互斥对象,该互斥对象内部计数器的值为0,同时将该对象设置为已通知状态.
 //对于互斥对象来说,谁拥有谁释放
 Sleep(40000);
}
DWORD WINAPI Fun1Proc(LPVOID lpParameter)
{
 while (TRUE)
 {
  WaitForSingleObject(hMutex,INFINITE);//等待互斥对象有信号
  if (tickets>0)
  {
   Sleep(1);
   cout<<"thread1 sell ticket :"<<tickets--<<endl;
  }
  else
   break;
  ReleaseMutex(hMutex);//设置该互斥对象的线程ID为0,并且将该对象设置为有信号状态
 }
 return 0;
}
DWORD WINAPI Fun2Proc(LPVOID lpParameter)
{
 while (TRUE)
 {
  WaitForSingleObject(hMutex,INFINITE);
  if (tickets>0)
  {
   Sleep(1);
   cout<<"thread2 sell ticket :"<<tickets--<<endl;
  }
  else
   break;
  ReleaseMutex(hMutex);
 }
 return 0;
}

--------------------------------------------------------------------------------

三、使用事件对象
HANDLE     CreateEvent(   
        LPSECURITY_ATTRIBUTES     lpEventAttributes,           //     SD   
        BOOL     bManualReset,                                                 //     reset     type   
        BOOL     bInitialState,                                                     //     initial     state   
        LPCTSTR     lpName                                                      //     object     name   
    );   
    该函数创建一个Event同步对象,并返回该对象的Handle   
    
    lpEventAttributes     一般为NULL   
    bManualReset               创建的Event是自动复位还是人工复位     ,如果true,人工复位,   
    一旦该Event被设置为有信号,则它一直会等到ResetEvent()API被调用时才会恢复   
    为无信号.     如果为false,Event被设置为有信号,则当有一个wait到它的Thread时,   
    该Event就会自动复位,变成无信号.   
    bInitialState             初始状态,true,有信号,false无信号   
    lpName                           Event对象名   
    
    一个Event被创建以后,可以用OpenEvent()API来获得它的Handle,用CloseHandle()   
    来关闭它,用SetEvent()或PulseEvent()来设置它使其有信号,用ResetEvent()   
    来使其无信号,用WaitForSingleObject()或WaitForMultipleObjects()来等待   
    其变为有信号.   
    
    PulseEvent()是一个比较有意思的使用方法,正如这个API的名字,它使一个Event   
    对象的状态发生一次脉冲变化,从无信号变成有信号再变成无信号,而整个操作是原子的.   
    对自动复位的Event对象,它仅释放第一个等到该事件的thread（如果有),而对于   
    人工复位的Event对象,它释放所有等待的thread.  
#include <windows.h>
#include <iostream>
using namespace std;
DWORD WINAPI Fun1Proc(LPVOID lpParameter);
DWORD WINAPI Fun2Proc(LPVOID lpParameter);
int tickets=100;
HANDLE g_hEvent;
void main()
{
 HANDLE hThread1;
 HANDLE hThread2;
 //**************************************************
 //创建一个命名的自动重置事件内核对象
 g_hEvent=CreateEvent(NULL,FALSE,FALSE,LPCTSTR("tickets"));
 if (g_hEvent)
 {
  if (ERROR_ALREADY_EXISTS==GetLastError())
  {
   cout<<"only one instance can run!"<<endl;
   return;
  }
 }
 //**************************************************
 SetEvent(g_hEvent);
 //创建线程
 hThread1=CreateThread(NULL,0,Fun1Proc,NULL,0,NULL);
 hThread2=CreateThread(NULL,0,Fun2Proc,NULL,0,NULL);
 Sleep(40000);
 //关闭事件对象句柄
 CloseHandle(g_hEvent);
}
DWORD WINAPI Fun1Proc(LPVOID lpParameter)
{
 while (TRUE)
 {
  WaitForSingleObject(g_hEvent,INFINITE);
  //ResetEvent(g_hEvent);
  if (tickets>0)
  {
   Sleep(1);
   cout<<"thread1 sell ticket :"<<tickets--<<endl;
   SetEvent(g_hEvent);
  }
  else
  {
   SetEvent(g_hEvent);
   break;
  }
 }
 return 0;
}
DWORD WINAPI Fun2Proc(LPVOID lpParameter)
{
 while (TRUE)
 {
  WaitForSingleObject(g_hEvent,INFINITE);
  //ResetEvent(g_hEvent);
  if (tickets>0)
  {
   cout<<"Thread2 sell ticket :"<<tickets--<<endl;
   SetEvent(g_hEvent);
  }
  else
  {
   SetEvent(g_hEvent);
   break;
  }
 }
 return 0;













C++之多线程编程
sunshine
02-28 428
C++之多线程编程 学多线程的主要原因是疫情来临，每天在家实在是啥也不相干，论文写不出来，就说提升一下编程技能吧。 学多线程的主要目的： 研究方向是多传感器融合SLAM算法，SLAM系统对实时性要求比较高，大多数SLAM开源系统都使用了多线程技术。 在公司实习一段时间，潜移默化中天天听到数据的高并发这些词语，因为公司这块数据量比较大。 所以决定了解一下多线程编程。 下面这篇博客看完可以直接上手...
一个基于C++的多线程编程实例(CreateThread函数)
净无邪博客
12-07 5460
本博客主要总结了基于C++的多线程函数CreateThread，互斥锁（或者称资源独占）函数CreateMutex，等待资源函数WaitForSingleObject，关闭线程函数(其实是关闭线程的句柄)CloseHanlde，释放互斥锁函数ReleaseMutex的用法实例，具体的程序用法和解释如下文所示： 一、基于CreateThread函数的多线程程序 1.1程序的功能是：主线程
C++多线程编程（入门实例）
weixin_33834137的博客
09-27 432
      　　多线程在编程中有相当重要的地位，我们在实际开发时或者找工作面试时总能遇到多线程的问题，对多线程的理解程度从一个侧面反映了程序员的编程水平。 　　其实C++语言本身并没有提供多线程机制（当然目前C++ 11新特性中，已经可以使用std::thread来创建线程了，因为还没有系统地了解过，所以这里不提了。），但Windows系统为我们提供了相关API，我们可以使用他们来进行多线...
C++学习系列（9）：多线程编程基础
最新发布
Azperk的博客
03-06 470
轻松创建多线程✅使用std::mutex进行同步，防止数据竞争✅条件变量适用于线程通信✅线程池是多线程优化的核心在下一篇C++学习系列（10）中，我们将探讨C++ STL 容器底层原理，敬请期待！🚀💡。
C++新建线程实例
黄兴丽的专栏
01-28 954
#include #include #include #include #include #include using namespace std; 在linux 系统下运行，windows下不可以，貌似要下个包。具体google. pthread_create的函数原型为： int pthread_create(pthread_t *thre
C ++中线程的简单示例
asdfgh0077的博客
02-09 384
有人可以发布一个简单的示例来说明如何在C ++中启动两个（面向对象）线程。 我正在寻找可以扩展运行方法（或类似方法）的实际C ++线程对象，而不是调用C样式线程库。 我遗漏了任何特定于
c++ 程序事例
04-23
从给定的文件信息中，我们可以提取出一系列与C++编程相关的知识点，这些知识点主要围绕着C++标准库函数的应用，以及部分特定于早期编译器（如TurboC2.0和BorlandC++）的库函数。下面将详细解析其中的几个关键函数...
QT系统编程中内存进程与Memory事例应用实例
QT框架具有良好的模块化设计，支持包括但不限于二维图形渲染、数据库集成、网络编程、多线程等高级特性。 3. 内存管理与进程控制 在系统编程中，内存管理是一个核心概念，它涉及到内存的分配、使用和回收。一个良好...
Node.js And C++__9.Addons替代解决方案
nihaoweixiao的博客
07-18 832
​ 注:本附录主要取自作者网站blog.scottfrees.com上的一系列博客文章，其中涵盖了将现有的C/C++程序*集成到一个Node.js 的各种方法。这个系列是独立于本书的，因此，您可能会发现其中的一些内容是多余的，但是它展示了一个真实的例子，它集成了legacy（老版本）的c++代码，而不是书中狭义的例子。该部分还有一个不同的github存储库，可以从本书的其他例子中下载代码。强烈...
局域网聊天源代码，一个简单的事例
01-04
2. **多线程编程**： - 为了实现即时聊天，程序通常需要处理接收和发送信息的并发操作。这需要使用多线程或多进程技术，确保聊天应用在接收新消息的同时能够及时发送出去。 3. **套接字编程**： - **Socket接口**...
MyThreadPool
10-09
线程池是多线程编程中的一个重要概念，它提供了一种高效管理线程资源的方式，有效地避免了频繁创建和销毁线程带来的开销。在Java、C#等编程语言中，都有内置的线程池实现，如Java的`ExecutorService`和C#的`...
c++多线程编程
09-18
本文简介了pthread的用法，介绍了多核多线程编程的入门知识
简单的c++多线程例子
qq_36162275的博客
02-17 463
#include &lt;iostream&gt; #include &lt;thread&gt; using namespace std; void output(int i) { cout&lt;&lt;i&lt;&lt;endl; } int main() { cout &lt;&lt; "Hello world!" &lt;&lt; endl; for
C++ 多线程编程实例
seekcreation的专栏
10-14 1791
从网上搜集来的非常基础的C++多线程实例，刚入门的可以看看，希望能有所帮助。 Cpp代码  //这是2个线程模拟卖火车票的小程序    #include     #include        DWORD WINAPI Fun1Proc(LPVOID lpParameter);//thread data    DWORD WINAPI Fun2Proc(LPVOID lp
c++多线程基本样例
Zerore的博客
05-28 227
#include <stdio.h> #include <string.h> #include <stdlib.h> #include <unistd.h> #include <pthread.h> void *myfunc1(void *arg); void *myfunc2(void *arg); int main() { pthread_t pthid1; pthread_t pthid2; long clientfd = 3;
C++ | C++多线程编程
I_feige的博客
09-25 2999
C++ | C++多线程编程 C++ 多线程 多线程是多任务处理的一种特殊形式，多任务处理允许让电脑同时运行两个或两个以上的程序。 一般情况下，两种类型的多任务处理：基于进程和基于线程。 基于进程的多任务处理是程序的并发执行。 基于线程的多任务处理是同一程序的片段的并发执行。 创建线程 PTHREAD_CREATE(3) Linux Programmer's Manual PTHREAD_CREATE(3) NAME pthread_create -
C、C++多线程编程
Jiangtagong的博客
08-14 939
一、线程概述 进程对应的虚拟地址空间的各个分区如图： 每个进程的虚拟地址空间都是从0地址开始的，在程序中打印的变量也是在虚拟地址的，程序是无法直接访问物理内存的。虚拟地址空间中用户地址空间的范围为：0~3G，里边分为多个区块。 线程是轻量级的进程（lightweightprocess），在Linux环境下线程的本质仍然是进程，在计算机运行的程序是一组指令以及指令参数的组合，指令按照既定的逻辑控制计算运行，操作系统会以进程为单位，分配系统资源，可...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值