MFC多线程

当前流行的Windows操作系统能同时运行几个程序(独立运行的程序又称之为进程),对于同一个程序,它又可以分成若干个独立的执行流,我们称之为线程,线程提供了多任务处理的能力。用进程和线程的观点来研究软件是当今普遍采用的方法,进程和线程的概念的出现,对提高软件的并行性有着重要的意义。现在的大型应用软件无一不是多线程多任务处理,单线程的软件是不可想象的。因此掌握多线程多任务设计方法对每个程序员都是必需要掌握的。本实例针对多线程技术在应用中经常遇到的问题,如线程间的通信、同步等,分别进行探讨,并利用多线程技术进行线程之间的通信,实现了数字的简单排序。   一、 实现方法 1、理解线程   要讲解线程,不得不说一下进程,进程是应用程序的执行实例,每个进程是由私有的虚拟地址空间、代码、 数据和其它系统资源组成。进程在运行时创建的资源随着进程的终止而死亡。线程的基本思想很简单,它是一 个独立的执行流,是进程内部的一个独立的执行单元,相当于一个子程序,它对应于Visual C++中的CwinThread 类对象。单独一个执行程序运行时,缺省地包含的一个主线程,主线程以函数地址的形式出现,提供程序的启动点 ,如main()或WinMain()函数等。当主线程终止时,进程也随之终止。根据实际需要,应用程序可以分解成许 多独立执行的线程,每个线程并行的运行在同一进程中。   一个进程中的所有线程都在该进程的虚拟地址空间中,使用该进程的全局变量和系统资源。操作系统给每个 线程分配不同的CPU时间片,在某一个时刻,CPU只执行一个时间片内的线程,多个时间片中的相应线程在CPU内轮 流执行,由于每个时间片时间很短,所以对用户来说,仿佛各个线程在计算机中是并行处理的。操作系统是根据线 程的优先级来安排CPU的时间,优先级高的线程优先运行,优先级低的线程则继续等待。   线程被分为两种:用户界面线程和工作线程(又称为后台线程)。用户界面线程通常用来处理用户的输入并 响应各种事件和消息,其实,应用程序的主执行线程CWinAPP对象就是一个用户界面线程,当应用程序启动时自动 创建和启动,同样它的终止也意味着该程序的结束,进程终止。工作线程用来执行程序的后台处理任务,比如计 算、调度、对串口的读写操作等,它和用户界面线程的区别是它不用从CWinThread类派生来创建,对它来说最重 要的是如何实现工作线程任务的运行控制函数。工作线程和用户界面线程启动时要调用同一个函数的不同版本;最 后需要读者明白的是,一个进程中的所有线程共享它们父进程的变量,但同时每个线程可以拥有自己的变量。   2、线程的管理和操作   (一)线程的启动   创建一个用户界面线程,首先要从类CwinThread产生一个派生类,同时必须使用DECLARE_DYNCREATE和 IMPLEMENT_DYNCREATE来声明和实现这个CwinThread派生类。 第二步是根据需要重载该派生类的一些成员函数如: ExitInstance()、 InitInstance()、 OnIdle()、 PreTranslateMessage()等函数。最后调用AfxBeginThread()函数的一个版本: CWinThread* AfxBeginThread( CRuntimeClass* pThreadClass, int nPriority = THREAD_PRIORITY_NORMAL, UINT nStackSize = 0, DWORD dwCreateFlags = 0, LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL ) 启动该用户界面线程,其中第一个参数为指向定义的用户界面线程类 指针变量,第二个参数为线程的优先级,第三个参数为线程所对应的堆栈大小,第四个参数为线程创建时的附加标志,缺省为正 常状态,如为CREATE_SUSPENDED则线程启动后为挂起状态。   对于工作线程来说,启动一个线程,首先需要编写一个希望与应用程序的其余部分并行运行的函数如Fun1(),接着定义一个指向CwinThread对象的指针变量*pThread,调用AfxBeginThread(Fun1,param,priority)函数,返回值赋给pThread变量的同时一并启动该线程来执行上面的Fun1()函数,其中Fun1是线程要运行的函数的名字,也既是上面所说的控制函数的名字,param是准备传送给线程函数Fun1的任意32位值,priority则是定义该线程的优先级别,它是预定义的常数,读者可参考MSDN。 (二)线程的优先级   以下的CwinThread类的成员函数用于线程优先级的操作: int GetThreadPriority(); BOOL SetThradPriority()(int nPriority);   上述的二个函数分别用来获取和设置线程的优先级,这里的优先级,是相对于该线程所处的优先权层次 而言的,处于同一优先权层次的线程,优先级高的线程先运行;处于不同优先权层次上的线程,谁的优先权 层次高,谁先运行。至于优先级设置所需的常数,自己参考MSDN就可以了,要注意的是要想设置线程的优先 级,这个线程在创建时必须具有THREAD_SET_INFORMATION访问权限。对于线程的优先权层次的设置, CwinThread类没有提供相应的函数,但是可以通过Win32 SDK函数GetPriorityClass()和SetPriorityClass() 来实现。 (三)线程的悬挂和恢复   CWinThread类中包含了应用程序悬挂和恢复它所创建的线程的函数,其中SuspendThread()用来悬挂线程,暂停线程的执行;ResumeThread()用来恢复线程的执行。如果你对一个线程连续若干次执行SuspendThread(),则需要连续执行相应次的ResumeThread()来恢复线程的运行。 (四)结束线程   终止线程有三种途径,线程可以在自身内部调用AfxEndThread()来终止自身的运行;可以在线程的外部调用 BOOL TerminateThread( HANDLE hThread, DWORD dwExitCode )来强行终止一个线程的运行,然后调用 CloseHandle()函数释放线程所占用的堆栈;第三种方法是改变全局变量,使线程的执行函数返回,则该线程终止。 下面以第三种方法为例,给出部分代码: //////////////////////////////////////////////////////////////// //////CtestView message handlers ///// Set to True to end thread Bool bend=FALSE;//定义的全局变量,用于控制线程的运行; // The Thread Function; UINT ThreadFunction(LPVOID pParam)//线程函数 {   while(!bend)   {    Beep(100,100);    Sleep(1000);   }   return 0; } ///////////////////////////////////////////////////////////// CwinThread *pThread; HWND hWnd; Void CtestView::OninitialUpdate() {   hWnd=GetSafeHwnd();   pThread=AfxBeginThread(ThradFunction,hWnd);//启动线程   pThread->m_bAutoDelete=FALSE;//线程为手动删除   Cview::OnInitialUpdate(); } //////////////////////////////////////////////////////////////// Void CtestView::OnDestroy() {   bend=TRUE;//改变变量,线程结束   WaitForSingleObject(pThread->m_hThread,INFINITE);//等待线程结束   delete pThread;//删除线程   Cview::OnDestroy(); }   3、线程之间的通信   通常情况下,一个次级线程要为主线程完成某种特定类型的任务,这就隐含着表示在主线程 和次级线程之间需要建立一个通信的通道。一般情况下,有下面的几种方法实现这种通信任务: 使用全局变量(上一节的例子其实使用的就是这种方法)、使用事件对象、使用消息。这里我们 主要介绍后两种方法。   (一) 利用用户定义的消息通信   在Windows程序设计中,应用程序的每一个线程都拥有自己的消息队列,甚至工作线程也不 例外,这样一来,就使得线程之间利用消息来传递信息就变的非常简单。首先用户要定义一个用 户消息,如下所示:#define WM_USERMSG WMUSER+100;在需要的时候,在一个线程中调用:: PostMessage((HWND)param,WM_USERMSG,0,0)或CwinThread::PostThradMessage()来向另外 一个线程发送这个消息,上述函数的四个参数分别是消息将要发送到的目的窗口的句柄、要发送 的消息标志符、消息的参数WPARAM和LPARAM。下面的代码是对上节代码的修改,修改后的结果 是在线程结束时显示一个对话框,提示线程结束:

UINT ThreadFunction(LPVOID pParam) {  while(!bend)  {   Beep(100,100);   Sleep(1000);  }  ::PostMessage(hWnd,WM_USERMSG,0,0);  return 0; } ////////WM_USERMSG消息的响应函数为OnThreadended(WPARAM wParam, LPARAM lParam) LONG CTestView::OnThreadended(WPARAM wParam,LPARAM lParam) {  AfxMessageBox("Thread ended.");  Retrun 0; }   上面的例子是工作者线程向用户界面线程发送消息,对于工作者线程,如果它的设计模式也 是消息驱动的,那么调用者可以向它发送初始化、退出、执行某种特定的处理等消息,让它在后 台完成。在控制函数中可以直接使用::GetMessage()这个SDK函数进行消息分检和处理,自己 实现一个消息循环。GetMessage()函数在判断该线程的消息队列为空时,线程将系统分配给它的 时间片让给其它线程,不无效的占用CPU的时间,如果消息队列不为空,就获取这个消息,判断这 个消息的内容并进行相应的处理。   (二)用事件对象实现通信   在线程之间传递信号进行通信比较复杂的方法是使用事件对象,用MFC的Cevent类的对象来 表示。事件对象处于两种状态之一:有信号和无信号,线程可以监视处于有信号状态的事件,以 便在适当的时候执行对事件的操作。上述例子代码修改如下:

//////////////////////////////////////////////////////////////////// Cevent threadStart ,threadEnd; UINT ThreadFunction(LPVOID pParam) {  ::WaitForSingleObject(threadStart.m_hObject,INFINITE);  AfxMessageBox("Thread start.");  while(!bend)  {   Beep(100,100);   Sleep(1000);   Int result=::WaitforSingleObject(threadEnd.m_hObject,0);   //等待threadEnd事件有信号,无信号时线程在这里悬停   If(result==Wait_OBJECT_0)    Bend=TRUE;  }  ::PostMessage(hWnd,WM_USERMSG,0,0);  return 0; } ///////////////////////////////////////////////////////////// Void CtestView::OninitialUpdate() {  hWnd=GetSafeHwnd();  threadStart.SetEvent();//threadStart事件有信号  pThread=AfxBeginThread(ThreadFunction,hWnd);//启动线程  pThread->m_bAutoDelete=FALSE;  Cview::OnInitialUpdate(); } //////////////////////////////////////////////////////////////// Void CtestView::OnDestroy() {  threadEnd.SetEvent();  WaitForSingleObject(pThread->m_hThread,INFINITE);  delete pThread;  Cview::OnDestroy(); }   运行这个程序,当关闭程序时,才显示提示框,显示"Thread ended"。

  4、线程之间的同步   前面我们讲过,各个线程可以访问进程中的公共变量,所以使用多线程的过程中需要注意的 问题是如何防止两个或两个以上的线程同时访问同一个数据,以免破坏数据的完整性。保证各个 线程可以在一起适当的协调工作称为线程之间的同步。前面一节介绍的事件对象实际上就是一种 同步形式。Visual C++中使用同步类来解决操作系统的并行性而引起的数据不安全的问题,MFC 支持的七个多线程的同步类可以分成两大类:同步对象(CsyncObject、Csemaphore、Cmutex、 CcriticalSection和Cevent)和同步访问对象(CmultiLock和CsingleLock)。本节主要介绍临 界区(critical section)、互斥(mutexe)、信号量(semaphore),这些同步对象使各个线 程协调工作,程序运行起来更安全。   (一) 临界区   临界区是保证在某一个时间只有一个线程可以访问数据的方法。使用它的过程中,需要给 各个线程提供一个共享的临界区对象,无论哪个线程占有临界区对象,都可以访问受到保护的数 据,这时候其它的线程需要等待,直到该线程释放临界区对象为止,临界区被释放后,另外的线 程可以强占这个临界区,以便访问共享的数据。临界区对应着一个CcriticalSection对象,当线 程需要访问保护数据时,调用临界区对象的Lock()成员函数;当对保护数据的操作完成之后,调 用临界区对象的Unlock()成员函数释放对临界区对象的拥有权,以使另一个线程可以夺取临界区 对象并访问受保护的数据。同时启动两个线程,它们对应的函数分别为WriteThread()和 ReadThread(),用以对公共数组组array[]操作,下面的代码说明了如何使用临界区对象:

#include "afxmt.h" int array[10],destarray[10]; CCriticalSection Section; UINT WriteThread(LPVOID param) {  Section.Lock();  for(int x=0;x<10;x++)   array[x]=x;  Section.Unlock(); } UINT ReadThread(LPVOID param) {  Section.Lock();  For(int x=0;x<10;x++)   Destarray[x]=array[x];   Section.Unlock(); }   上述代码运行的结果应该是Destarray数组中的元素分别为1-9,而不是杂乱无章的数,如 果不使用同步,则不是这个结果,有兴趣的读者可以实验一下。   (二)互斥   互斥与临界区很相似,但是使用时相对复杂一些,它不仅可以在同一应用程序的线程间实 现同步,还可以在不同的进程间实现同步,从而实现资源的安全共享。互斥与Cmutex类的对象 相对应,使用互斥对象时,必须创建一个CSingleLock或CMultiLock对象,用于实际的访问控 制,因为这里的例子只处理单个互斥,所以我们可以使用CSingleLock对象,该对象的Lock() 函数用于占有互斥,Unlock()用于释放互斥。实现代码如下:

#include "afxmt.h" int array[10],destarray[10]; CMutex Section; UINT WriteThread(LPVOID param) {  CsingleLock singlelock;  singlelock (&Section);  singlelock.Lock();  for(int x=0;x<10;x++)   array[x]=x;  singlelock.Unlock(); } UINT ReadThread(LPVOID param) {  CsingleLock singlelock;  singlelock (&Section);  singlelock.Lock();  For(int x=0;x<10;x++)   Destarray[x]=array[x];   singlelock.Unlock(); }   (三)信号量   信号量的用法和互斥的用法很相似,不同的是它可以同一时刻允许多个线程访问同一个 资源,创建一个信号量需要用Csemaphore类声明一个对象,一旦创建了一个信号量对象,就 可以用它来对资源的访问技术。要实现计数处理,先创建一个CsingleLock或CmltiLock对 象,然后用该对象的Lock()函数减少这个信号量的计数值,Unlock()反之。下面的代码分别 启动三个线程,执行时同时显示二个消息框,然后10秒后第三个消息框才得以显示。 ============================================================================ |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| ---------------------------------------------------------------------------- Csemaphore *semaphore; Semaphore=new Csemaphore(2,2); HWND hWnd=GetSafeHwnd(); AfxBeginThread(threadProc1,hWnd); AfxBeginThread(threadProc2,hWnd); AfxBeginThread(threadProc3,hWnd); UINT ThreadProc1(LPVOID param) {  CsingleLock singelLock(semaphore);  singleLock.Lock();  Sleep(10000);  ::MessageBox((HWND)param,"Thread1 had access","Thread1",MB_OK);  return 0; } UINT ThreadProc2(LPVOID param) {  CSingleLock singelLock(semaphore);  singleLock.Lock();  Sleep(10000);  ::MessageBox((HWND)param,"Thread2 had access","Thread2",MB_OK);  return 0; } UINT ThreadProc3(LPVOID param) {  CsingleLock singelLock(semaphore);  singleLock.Lock();  Sleep(10000);  ::MessageBox((HWND)param,"Thread3 had access","Thread3",MB_OK);  return 0; }

二、 编程步骤   1、 启动Visual C++6.0,生成一个32位的控制台程序,将该程序命名为"sequence"   2、 输入要排续的数字,声明四个子线程;   3、 输入代码,编译运行程序。 三、 程序代码 ////////////////////////////////////////////////////////////////////////////////////// // sequence.cpp : Defines the entry point for the console application. #include "stdafx.h" #include "stdlib.h" #include "memory.h" HANDLE evtTerminate; //事件信号,标记是否所有子线程都执行完

HANDLE evtPrint; //事件信号,标记事件是否已发生 //CRITICAL_SECTION csPrint; //临界区 //HANDLE mtxPrint; //互斥信号,如有信号表明已经有线程进入临界区并拥有此信号 static long ThreadCompleted = 0; //下面的结构是用于传送排序的数据给各个排序子线程 struct MySafeArray {  long* data;  int iLength; }; //打印每一个线程的排序结果 void PrintResult(long* Array, int iLength, const char* HeadStr = "sort"); //排序函数 unsigned long __stdcall BubbleSort(void* theArray); //冒泡排序 unsigned long __stdcall SelectSort(void* theArray); //选择排序 unsigned long __stdcall HeapSort(void* theArray); //堆排序 unsigned long __stdcall InsertSort(void* theArray); //插入排序 int QuickSort(long* Array, int iLow, int iHigh); //快速排序 int main(int argc, char* argv[]) {  long data[] = {123,34,546,754,34,74,3,56};  int iDataLen = 8;  //为了对各个子线程分别对原始数据进行排序和保存排序结果  //分别分配内存对data数组的数据进行复制  long *data1, *data2, *data3, *data4, *data5;  MySafeArray StructData1, StructData2, StructData3, StructData4;  data1 = new long[iDataLen];  memcpy(data1, data, iDataLen << 2); //把data中的数据复制到data1中  //内存复制 memcpy(目标内存指针, 源内存指针, 复制字节数), 因为long的长度  //为4字节,所以复制的字节数为iDataLen << 2, 即等于iDataLen*4  StructData1.data = data1;  StructData1.iLength = iDataLen;  data2 = new long[iDataLen];  memcpy(data2, data, iDataLen << 2);  StructData2.data = data2;  StructData2.iLength = iDataLen;  data3 = new long[iDataLen];  memcpy(data3, data, iDataLen << 2);  StructData3.data = data3;  StructData3.iLength = iDataLen;  data4 = new long[iDataLen];  memcpy(data4, data, iDataLen << 2);  StructData4.data = data4;  StructData4.iLength = iDataLen;  data5 = new long[iDataLen];  memcpy(data5, data, iDataLen << 2);  unsigned long TID1, TID2, TID3, TID4;  //对信号量进行初始化  evtTerminate = CreateEvent(NULL, FALSE, FALSE, "Terminate");  evtPrint = CreateEvent(NULL, FALSE, TRUE, "PrintResult");  //分别建立各个子线程  CreateThread(NULL, 0, &BubbleSort, &StructData1, NULL, &TID1);  CreateThread(NULL, 0, &SelectSort, &StructData2, NULL, &TID2);  CreateThread(NULL, 0, &HeapSort, &StructData3, NULL, &TID3);  CreateThread(NULL, 0, &InsertSort, &StructData4, NULL, &TID4);  //在主线程中执行行快速排序,其他排序在子线程中执行  QuickSort(data5, 0, iDataLen - 1);  PrintResult(data5, iDataLen, "Quick Sort");  WaitForSingleObject(evtTerminate, INFINITE); //等待所有的子线程结束  //所有的子线程结束后,主线程才可以结束  delete[] data1;  delete[] data2;  delete[] data3;  delete[] data4;  CloseHandle(evtPrint);  return 0; }

unsigned long __stdcall BubbleSort(void* theArray) {  long* Array = ((MySafeArray*)theArray)->data;  int iLength = ((MySafeArray*)theArray)->iLength;  int i, j=0;  long swap;  for (i = iLength-1; i >0; i--)  {   for(j = 0; j < i; j++)   {    if(Array[j] >Array[j+1]) //前比后大,交换    {     swap = Array[j];     Array[j] = Array[j+1];     Array[j+1] = swap;    }   }  }  PrintResult(Array, iLength, "Bubble Sort"); //向控制台打印排序结果  InterlockedIncrement(&ThreadCompleted); //返回前使线程完成数标记加1  if(ThreadCompleted == 4) SetEvent(evtTerminate); //检查是否其他线程都已执行完  //若都执行完则设置程序结束信号量  return 0; }

unsigned long __stdcall SelectSort(void* theArray) {  long* Array = ((MySafeArray*)theArray)->data;  int iLength = ((MySafeArray*)theArray)->iLength;  long lMin, lSwap;  int i, j, iMinPos;  for(i=0; i < iLength-1; i++)  {   lMin = Array[i];   iMinPos = i;   for(j=i + 1; j <= iLength-1; j++) //从无序的元素中找出最小的元素   {    if(Array[j] < lMin)    {     iMinPos = j;     lMin = Array[j];    }   }   //把选出的元素交换拼接到有序序列的最后   lSwap = Array[i];   Array[i] = Array[iMinPos];   Array[iMinPos] = lSwap;  }  PrintResult(Array, iLength, "Select Sort"); //向控制台打印排序结果  InterlockedIncrement(&ThreadCompleted); //返回前使线程完成数标记加1  if(ThreadCompleted == 4) SetEvent(evtTerminate);//检查是否其他线程都已执行完  //若都执行完则设置程序结束信号量  return 0; }

unsigned long __stdcall HeapSort(void* theArray) {  long* Array = ((MySafeArray*)theArray)->data;  int iLength = ((MySafeArray*)theArray)->iLength;  int i, j, p;  long swap;  for(i=0; i {   for(j = iLength - 1; j>i; j--) //从最后倒数上去比较字节点和父节点   {    p = (j - i - 1)/2 + i; //计算父节点数组下标    //注意到树节点序数跟数组下标不是等同的,因为建堆的元素个数逐个递减    if(Array[j] < Array[p]) //如果父节点数值大则交换父节点和字节点    {     swap = Array[j];     Array[j] = Array[p];     Array[p] = swap;    }   }  }  PrintResult(Array, iLength, "Heap Sort"); //向控制台打印排序结果  InterlockedIncrement(&ThreadCompleted); //返回前使线程完成数标记加1  if(ThreadCompleted == 4) SetEvent(evtTerminate); //检查是否其他线程都已执行完  //若都执行完则设置程序结束信号量  return 0; }

unsigned long __stdcall InsertSort(void* theArray) {  long* Array = ((MySafeArray*)theArray)->data;  int iLength = ((MySafeArray*)theArray)->iLength;  int i=1, j=0;  long temp;  for(i=1; i {   temp = Array[i]; //取出序列后面无序数据的第一个元素值   for(j=i; j>0; j--) //和前面的有序数据逐个进行比较找出合适的插入位置   {    if(Array[j - 1] >temp) //如果该元素比插入值大则后移     Array[j] = Array[j - 1];    else //如果该元素比插入值小,那么该位置的后一位就是插入元素的位置     break;   }   Array[j] = temp;  }  PrintResult(Array, iLength, "Insert Sort"); //向控制台打印排序结果  InterlockedIncrement(&ThreadCompleted); //返回前使线程完成数标记加1  if(ThreadCompleted == 4) SetEvent(evtTerminate); //检查是否其他线程都已执行完   //若都执行完则设置程序结束信号量  return 0; } int QuickSort(long* Array, int iLow, int iHigh) {  if(iLow >= iHigh) return 1; //递归结束条件  long pivot = Array[iLow];  int iLowSaved = iLow, iHighSaved = iHigh; //保未改变的iLow,iHigh值保存起来  while (iLow < iHigh)  {   while (Array[iHigh] >= pivot && iHigh >iLow) //寻找比支点大的元素    iHigh -- ;   Array[iLow] = Array[iHigh]; //把找到的元素放置到空置的位置   while (Array[iLow] < pivot && iLow < iHigh) //寻找比支点小的元素    iLow ++ ;   Array[iHigh] = Array[iLow]; //把找到的元素放置到空置的位置 }  Array[iLow] = pivot; //把支点值放置到支点位置,这时支点位置是空置的  //对左右部分分别进行递归处理  QuickSort(Array, iLowSaved, iHigh-1);  QuickSort(Array, iLow+1, iHighSaved);  return 0; } //每一个线程都要使用这个函数进行输出,而且只有一个显示器,产生多个线程 //竞争对控制台的使用权。 void PrintResult(long* Array, int iLength, const char* HeadStr) {  WaitForSingleObject(evtPrint, INFINITE); //等待事件有信号  //EnterCriticalSection(&csPrint); //标记有线程进入临界区  //WaitForSingleObject(mtxPrint, INFINITE); //等待互斥量空置(没有线程拥有它)  int i;  printf("%s: ", HeadStr);  for (i=0; i {   printf("%d,", Array[i]);   Sleep(100); //延时(可以去掉)

 }  printf("%d\n", Array[i]);  SetEvent(evtPrint); //把事件信号量恢复,变为有信号 } 四、 小结   对复杂的应用程序来说,线程的应用给应用程序提供了高效、快速、安全的数据处理能力。本实例讲述了线程处理中经常遇到的问题,希望对读者朋友有一定的帮助,起到抛砖引玉的作用。 本栏文章均来自于互联网,版权归原作者和各发布网站所有,本站收集这些文章仅供学习参考之用。任何人都不能将这些文章用于商业或者其他目的。( ProgramFan.Com )

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏FD的专栏

一步步理解python的异步IO

看到越来越多的大佬都在使用python的异步IO,协程等概念来实现高效的IO处理过程,可是我对这些概念还不太懂,就学习了一下。 因为是初学者,在理解上有很多不到...

1562
来自专栏程序员维他命

YYCache 源码解析(一):使用方法,架构与内存缓存的设计

YYCache是国内开发者ibireme开源的一个线程安全的高性能缓存组件,代码风格简洁清晰,阅读它的源码有助于建立比较完整的缓存设计的思路,同时也能巩固一下双...

3602
来自专栏JackieZheng

探秘Tomcat——一个简易的Servlet容器

即便再简陋的服务器也是服务器,今天就来循着书本的第二章来看看如何实现一个servlet容器。 背景知识   既然说到servlet容器这个名词,我们首先要了解它...

2275
来自专栏微信公众号:Java团长

从并发编程到分布式系统——如何处理海量数据(上)

在这里想写写自己在学习并发处理的学习思路,也会聊聊自己遇到的那些坑,以此为记,希望鞭策自己不断学习、永不放弃!

771
来自专栏IT可乐

mybatis源码解读(三)——数据源的配置

1353
来自专栏分布式系统和大数据处理

.Net 项目代码风格参考

代码风格没有正确与否,重要的是整齐划一,这是我拟的一份《.Net 项目代码风格参考》,供大家参考。

1442
来自专栏用户2442861的专栏

web.xml配置详解

1、web.xml学名叫部署描述符文件,是在Servlet规范中定义的,是web应用的配置文件。

3671
来自专栏逆向技术

16位汇编语言第二讲系统调用原理,以及各个寄存器详解

   16位汇编语言第二讲系统调用原理,以及各个寄存器详解 昨天已将简单的写了一下汇编代码,并且执行了第一个显示到屏幕的helloworld 问题?   hel...

2240
来自专栏冰霜之地

如何设计并实现一个线程安全的 Map ?(下篇)

在上篇中,我们已经讨论过如何去实现一个 Map 了,并且也讨论了诸多优化点。在下篇中,我们将继续讨论如何实现一个线程安全的 Map。说到线程安全,需要从概念开始...

4917
来自专栏ASP.NETCore

在.NET Core程序中设置全局异常处理

但是在.NET Core中并没有AppDomain的相关实现,至少在.NET Core最新的发布版本里没有。

1263

扫码关注云+社区

领取腾讯云代金券