criticalsection

Critical Section和Mutex的不同点

1.Critical SectionA.速度快B.不能用于不同进程C.不能进行资源统计(每次只可以有一个线程对共享资源进行存取)2.MutexA.速度慢B.可用于不同进程C.不能进行资源统计3.SemaphoreA.速度慢B.可用于不同进程C.可进行资源统计(可以让一个或超过一个线程对共享资源进行存取)4.EventA.速度慢B.可用于不同进程C.可进行资源统计

ccriticalsection 用法 为什么是未定义标识符

CCriticalSection是对关键段CRITICAL_SECTION的封装。

关键段(critival section)是一小段代码，他在执行之前需要独占对一些共享资源的访问权。这种方式可以让多行代码以“原子方式”来对资源进行操控。这里的“原子方式”，指的是代码知道除了当前线程之外没有其他任何线程会同时访问该资源。当然，系统仍然可以暂停当前线程去调度其他线程。但是，在当前线程离开关键段之前，系统是不会去调度任何想要访问同一资源的其他线程的。
例如：如果两个线程同时访问一个链表，一个线程可能会在另一个线程搜寻元素的同时向链表中添加一个元素，将导致搜索结果不正确；还有可能两个线程同时向链表中添加元素，这种情况会变的更加混乱；甚至一个线程搜索的时候，另一个线程删除了链表节点，将直接导致程序崩溃。
解决这个问题，我们可以先在代码中定义一个CRITICAL_SECTION数据结构m_sect，然后把任何需要访问共享资源的代码放在EnterCriticalSection和LeaveCriticalSection之间。

[cpp] view plain copy print?
EnterCriticalSection(&m_sect);
// 共享资源的代码段....

LeaveCriticalSection(&m_sect);

一个 CRITICAL_SECTION结构就像是飞机上的一个卫生间，而马桶则是我们想要保护的资源（用EnterCriticalSection和LeaveCriticalSection组成的围墙包围住“马桶”）。由于卫生间很小，因此在同一时刻只允许一个人在卫生间内使用马桶（在同一时刻只允许一个线程在关键段中使用被保护资源）。
如果有多个总是应该在一起使用的资源，那么我们可以把他们放在同一个“卫生间”中：只需要创建一个CRITICAL_SECTION结构来保护所有这些资源。

关于关键段，需要掌握以下几点：
1、任何要访问共享资源的代码，都必须包含在EnterCriticalSection和LeaveCriticalSection之间。如果忘了哪怕是一个地方，共享资源就有可能被破坏。忘记调用EnterCriticalSection和LeaveCriticalSection，就好像是未经许可就强制进入卫生间一样，线程强行进入并对资源进行操控。只要有一个线程有这种粗暴的行为，资源就会被破坏。
2、关键段CRITICAL_SECTION是个未公开的结构，因为Microsoft认为开发人员不需要理解这个结构的细节。对我们来说，不需要知道这个结构中的成员变量，我们绝对不应该在编写代码的时候用到他的成员。
3、为了对CRITICAL_SECTION结构进行操控，我们必须调用Windows API函数，传入结构的地址。（注意是地址！）也就是说，如果该CRITICAL_SECTION结构生命周期没有结束，那么可以将该结构地址通过自己喜欢的任何方式传给任何线程。
4、在任何线程试图访问被保护的资源之前，必须对CRITICAL_SECTION结构的内部成员进程初始化。我们不知道内部成员，但可以调用Windows函数实现：VOID WINAPI InitializeCriticalSection(__out LPCRITICAL_SECTION lpCriticalSection);
5、当线程不再需要访问共享资源的时候，应调用下面的函数来清理该结构：VOID WINAPI DeleteCriticalSection(__inout LPCRITICAL_SECTION lpCriticalSection);

6、其实CRITICAL_SECTION并不知道什么是共享资源，也不会智能保护共享资源。其根本是，同一个时刻如果有多个线程调用EnterCriticalSection的时候，只有一个线程返回，其余线程则暂停执行，等待前面线程调用LeaveCriticalSection之后再执行。

7、可以看出，进入关键段是没有超时设定的，好像永远不会超时。实际上，对EnterCriticalSection的调用也会超时并引发异常。超时的时间长度由下面这个注册表子项中包含的CriticalSectionTimeout值决定：
HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager
这个值以秒为单位，他的默认值为2592000秒，大约30天。

8、同一个线程可以随便进入用一个关键段N次，也就是说同一个线程调用EnterCriticalSection无论几次都会返回。不同线程是否能够进入关键段，要看EnterCriticalSection的参数（CRITICAL_SECTION结构的地址）之前是否有线程进入过。要记住：飞机上的卫生间有多个，你可以随便进入无人的卫生间，不能进入有人的卫生间。


弄明白了CRITICAL_SECTION之后，使用CCriticalSection非常方便，如虎添翼。看代码：
//头文件
[cpp] view plain copy print?
class CCriticalSection : public CSyncObjet
{...
public:
CRITICAL_SECTION m_sect;
public:
BOOL Unlock();
BOOL Lock();
BOOL Lock(DWORD dwTimeout);
...
}

// 构造函数
[cpp] view plain copy print?
CCriticalSection::CCriticalSection() : CSyncObject(NULL)
{
HRESULT hr = S_OK;
if (!InitializeCriticalSectionAndSpinCount(&m_sect, 0))//可以理解为InitializeCriticalSection，为了效率，加了一个旋转锁。
{
hr = HRESULT_FROM_WIN32(GetLastError());
}

if (FAILED(hr))
{
AtlThrow(hr);
}
}


//进入关键段
[cpp] view plain copy print?
BOOL CCriticalSection::Lock()
{
::EnterCriticalSection(&m_sect);

return TRUE;
}


// 离开关键段
[cpp] view plain copy print?
BOOL CCriticalSection::Unlock()
{
::LeaveCriticalSection(&m_sect);

return TRUE;
}

// 析构
[cpp] view plain copy print?
CCriticalSection::~CCriticalSection()
{
::DeleteCriticalSection(&m_sect);
}

Visual Studio 中未定义标识符"NULL"

null：未声明的标识符的错误，通常是变量没有声明导致，用户需要根据提示找到出错所在行数，把 xxx 标识符声明下。需要特别注意null 全部需要大写，如果用户使用小写的 null，也会出现 error C2065。Visual Studio 支持用户透过多种不同的程序语言进行开发，但历代版本所支持的语言并不完全相同，例如Visual Studio .NET 2002 时，微软将 Visual J++ 改版为 Visual J#，但至 Visual Studio 2008 时取消支持 Visual J#；而 Visual Studio 2010 时，并入支持新语言 Visual F#。Visual Studio 2010 原生支持：Visual Basic、Visual C#、Visual C++、Visual F#四种程序语言。扩展资料：注意事项：注意是否是libcd.lib，与C/C++属性中的代码生成选项相关。当visual studio的快捷键和word冲突时，可以考虑取消word的所有加载项。将两个项目的运行时库统一。简单的方式就是将项目的动态库修改为使用Multithreaded DLL 版本的C运行时库即可，有时用户使用的库不是用户可以控制的，那么就只能把工程属性设置成河使用的库相同的选项。参考资料来源：百度百科-Visual Studio参考资料来源：百度百科-未定义变量参考资料来源：百度百科-Null

c++多线程问题

　　当多个线程访问一个独占性共享资源时,可以使用“临界区”对象。任一时刻只有一个线程可以拥有临界区对象，拥有临界区的线程可以访问被保护起来的资源或代码段，其他希望进入临界区的线程将被挂起等待，直到拥有临界区的线程放弃临界区时为止，这样就保证了不会在同一时刻出现多个线程访问共享资源。

CCriticalSection类的用法非常简单，步骤如下：
　

定义CCriticalSection类的一个全局对象（以使各个线程均能访问），如CCriticalSection critical_section；
在访问需要保护的资源或代码之前，调用CCriticalSection类的成员Lock（）获得临界区对象： critical_section.Lock();

在线程中调用该函数来使线程获得它所请求的临界区。如果此时没有其它线程占有临界区对象，则调用Lock()的线程获得临界区；否则，线程将被挂起，并放入到一个系统队列中等待，直到当前拥有临界区的线程释放了临界区时为止。
访问临界区完毕后，使用CCriticalSection的成员函数Unlock()来释放临界区：critical_section.Unlock();

再通俗一点讲，就是线程A执行到critical_section.Lock();语句时，如果其它线程(B)正在执行critical_section.Lock();语句后且critical_section. Unlock();语句前的语句时，线程A就会等待，直到线程B执行完critical_section. Unlock();语句，线程A才会继续执行。

临界区：是否每一次调用EnterCriticalSection()之前都必须初始

如果我在C/S三层结构中服务端定义两个事件。procedure tms.into;beginEnterCriticalSection();..end;procedure tms.out;beginLeaveCriticalSection();end;在客户端调用： // data1.SocketConnection1.AppServer.into; empty_sj; //中间是定义的一个过程,那么这个过程是否属于临界区中的事件。 data1.SocketConnection1.AppServer.out; 查看更多答案>>求采纳

C语言:操作系统临界区问题!

#include
#include
#include
#include
#define false 0
#define true 1

int flag[2];
int turn;

void P0()
{
while(true)
{
flag[0]=true;
turn = 1;
while(flag[1]&&turn==1)
;
printf ("P0 is in critical section.\n");
printf ("P0 is going to leave critical section.\n");
flag[0]=false;
printf ("P0 is out of critical section.\n");
}
}
void P1()
{
while(true)
{
flag[1]=true;
turn = 0;
while(flag[0]&&turn==0)
;
printf ("P1 is in critical section.\n");
printf ("P1 is going to leave critical section.\n");
flag[1]=false;
printf ("P1 is out of critical section.\n");
}
}
int main()
{
pthread_t pid0;
pthread_t pid1;
flag[0]=false;
flag[1]=false;
pthread_create(&pid0, NULL, (void*)P0, NULL);
pthread_create(&pid1, NULL, (void*)P1, NULL);
pthread_join(pid0, NULL);
pthread_join(pid1, NULL);
exit(0);
}
Linux系统下实现

谁能帮我写个MFC多线程实际例子 谢谢了

加按钮 还得MFC，代码不好 展示， 给你详细介绍，下面四种方法 在多线程中用，靠你多琢磨，灵活运用
现在流行的进程线程同步互斥的控制机制，其实是由最原始最基本的4种方法实现的。由这4种方法组合优化就有了.Net和Java下灵活多变的，编程简便的线程进程控制手段。 这4种方法具体定义如下 在《操作系统教程》ISBN 7-5053-6193-7 一书中可以找到更加详细的解释 1临界区:通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。 2互斥量:为协调共同对一个共享资源的单独访问而设计的。 3信号量:为控制一个具有有限数量用户资源而设计。 4事 件:用来通知线程有一些事件已发生，从而启动后继任务的开始。 临界区（Critical Section） 保证在某一时刻只有一个线程能访问数据的简便办法。在任意时刻只允许一个线程对共享资源进行访问。如果有多个线程试图同时访问临界区，那么在有一个线程 进入后其他所有试图访问此临界区的线程将被挂起，并一直持续到进入临界区的线程离开。临界区在被释放后，其他线程可以继续抢占，并以此达到用原子方式操作 共享资源的目的。 临界区包含两个操作原语： EnterCriticalSection（） 进入临界区 LeaveCriticalSection（） 离开临界区 EnterCriticalSection（）语句执行后代码将进入临界区以后无论发生什么，必须确保与之匹配的 LeaveCriticalSection（）都能够被执行到。否则临界区保护的共享资源将永远不会被释放。虽然临界区同步速度很快，但却只能用来同步本 进程内的线程，而不可用来同步多个进程中的线程。 MFC提供了很多功能完备的类，我用MFC实现了临界区。MFC为临界区提供有一个 CCriticalSection类，使用该类进行线程同步处理是非常简单的。只需在线程函数中用CCriticalSection类成员函数Lock （）和UnLock（）标定出被保护代码片段即可。Lock（）后代码用到的资源自动被视为临界区内的资源被保护。UnLock后别的线程才能访问这些资 源。 //CriticalSection CCriticalSection global_CriticalSection; // 共享资源 char global_Array[256]; //初始化共享资源 void InitializeArray() { for(int i = 0;iSetWindowText(""); //进入临界区 global_CriticalSection.Lock(); for(int i = 0;iSetWindowText(global_Array); Sleep(10); } //离开临界区 global_CriticalSection.Unlock(); return 0; } //删除线程 UINT Global_ThreadDelete(LPVOID pParam) { CEdit *ptr=(CEdit *)pParam; ptr->SetWindowText(""); //进入临界区 global_CriticalSection.Lock(); for(int i = 0;iSetWindowText(global_Array); Sleep(10); } //离开临界区 global_CriticalSection.Unlock(); return 0; } //创建线程并启动线程 void CCriticalSectionsDlg::OnBnClickedButtonLock() { //Start the first Thread CWinThread *ptrWrite = AfxBeginThread(Global_ThreadWrite, &m_Write, THREAD_PRIORITY_NORMAL, 0, CREATE_SUSPENDED); ptrWrite->ResumeThread(); //Start the second Thread CWinThread *ptrDelete = AfxBeginThread(Global_ThreadDelete, &m_Delete, THREAD_PRIORITY_NORMAL, 0, CREATE_SUSPENDED); ptrDelete->ResumeThread(); } 在测试程序中，Lock UnLock两个按钮分别实现，在有临界区保护共享资源的执行状态，和没有临界区保护共享资源的执行状态。 程序运行结果 互斥量（Mutex） 互斥量跟临界区很相似，只有拥有互斥对象的线程才具有访问资源的权限，由于互斥对象只有一个，因此就决定了任何情况下此共享资源都不会同时被多个线程所 访问。当前占据资源的线程在任务处理完后应将拥有的互斥对象交出，以便其他线程在获得后得以访问资源。互斥量比临界区复杂。因为使用互斥不仅仅能够在同一 应用程序不同线程中实现资源的安全共享，而且可以在不同应用程序的线程之间实现对资源的安全共享。 互斥量包含的几个操作原语： CreateMutex（） 创建一个互斥量 OpenMutex（） 打开一个互斥量 ReleaseMutex（） 释放互斥量 WaitForMultipleObjects（） 等待互斥量对象 同样MFC为互斥量提供有一个CMutex类。使用CMutex类实现互斥量操作非常简单，但是要特别注意对CMutex的构造函数的调用 CMutex( BOOL bInitiallyOwn = FALSE, LPCTSTR lpszName = NULL, LPSECURITY_ATTRIBUTES lpsaAttribute = NULL) 不用的参数不能乱填，乱填会出现一些意想不到的运行结果。 //创建互斥量 CMutex global_Mutex(0,0,0); // 共享资源 char global_Array[256]; void InitializeArray() { for(int i = 0;iSetWindowText(""); global_Mutex.Lock(); for(int i = 0;iSetWindowText(global_Array); Sleep(10); } global_Mutex.Unlock(); return 0; } UINT Global_ThreadDelete(LPVOID pParam) { CEdit *ptr=(CEdit *)pParam; ptr->SetWindowText(""); global_Mutex.Lock(); for(int i = 0;iSetWindowText(global_Array); Sleep(10); } global_Mutex.Unlock(); return 0; } 同样在测试程序中，Lock UnLock两个按钮分别实现，在有互斥量保护共享资源的执行状态，和没有互斥量保护共享资源的执行状态。 信号量（Semaphores） 信号量对象对线程的同步方式与前面几种方法不同，信号允许多个线程同时使用共享资源，这与操作系统中的PV操作相同。它指出了同时访问共享资源的线程最 大数目。它允许多个线程在同一时刻访问同一资源，但是需要限制在同一时刻访问此资源的最大线程数目。在用CreateSemaphore（）创建信号量时 即要同时指出允许的最大资源计数和当前可用资源计数。一般是将当前可用资源计数设置为最大资源计数，每增加一个线程对共享资源的访问，当前可用资源计数就 会减1，只要当前可用资源计数是大于0的，就可以发出信号量信号。但是当前可用计数减小到0时则说明当前占用资源的线程数已经达到了所允许的最大数目，不 能在允许其他线程的进入，此时的信号量信号将无法发出。线程在处理完共享资源后，应在离开的同时通过ReleaseSemaphore（）函数将当前可用 资源计数加1。在任何时候当前可用资源计数决不可能大于最大资源计数。 PV操作及信号量的概念都是由荷兰科学家E.W.Dijkstra提出的。信号量S是一个整数，S大于等于零时代表可供并发进程使用的资源实体数，但S小于零时则表示正在等待使用共享资源的进程数。 P操作 申请资源： （1）S减1； （2）若S减1后仍大于等于零，则进程继续执行； （3）若S减1后小于零，则该进程被阻塞后进入与该信号相对应的队列中，然后转入进程调度。 V操作 释放资源： （1）S加1； （2）若相加结果大于零，则进程继续执行； （3）若相加结果小于等于零，则从该信号的等待队列中唤醒一个等待进程，然后再返回原进程继续执行或转入进程调度。 信号量包含的几个操作原语： CreateSemaphore（） 创建一个信号量 OpenSemaphore（） 打开一个信号量 ReleaseSemaphore（） 释放信号量 WaitForSingleObject（） 等待信号量 //信号量句柄 HANDLE global_Semephore; // 共享资源 char global_Array[256]; void InitializeArray() { for(int i = 0;iSetWindowText(""); //等待对共享资源请求被通过 等于 P操作 WaitForSingleObject(global_Semephore, INFINITE); for(int i = 0;iSetWindowText(global_Array); Sleep(10); } //释放共享资源 等于 V操作 ReleaseSemaphore(global_Semephore, 1, NULL); return 0; } UINT Global_ThreadTwo(LPVOID pParam) { CEdit *ptr=(CEdit *)pParam; ptr->SetWindowText(""); WaitForSingleObject(global_Semephore, INFINITE); for(int i = 0;iSetWindowText(global_Array); Sleep(10); } ReleaseSemaphore(global_Semephore, 1, NULL); return 0; } UINT Global_ThreadThree(LPVOID pParam) { CEdit *ptr=(CEdit *)pParam; ptr->SetWindowText(""); WaitForSingleObject(global_Semephore, INFINITE); for(int i = 0;iSetWindowText(global_Array); Sleep(10); } ReleaseSemaphore(global_Semephore, 1, NULL); return 0; } void CSemaphoreDlg::OnBnClickedButtonOne() { //设置信号量 1 个资源 1同时只可以有一个线程访问 global_Semephore= CreateSemaphore(NULL, 1, 1, NULL); this->StartThread(); // TODO: Add your control notification handler code here } void CSemaphoreDlg::OnBnClickedButtonTwo() { //设置信号量 2 个资源 2 同时只可以有两个线程访问 global_Semephore= CreateSemaphore(NULL, 2, 2, NULL); this->StartThread(); // TODO: Add your control notification handler code here } void CSemaphoreDlg::OnBnClickedButtonThree() { //设置信号量 3 个资源 3 同时只可以有三个线程访问 global_Semephore= CreateSemaphore(NULL, 3, 3, NULL); this->StartThread(); // TODO: Add your control notification handler code here } 信号量的使用特点使其更适用于对Socket（套接字）程序中线程的同步。例如，网络上的HTTP服务器要对同一时间内访问同一页面的用户数加以限制， 这时可以为每一个用户对服务器的页面请求设置一个线程，而页面则是待保护的共享资源，通过使用信号量对线程的同步作用可以确保在任一时刻无论有多少用户对 某一页面进行访问，只有不大于设定的最大用户数目的线程能够进行访问，而其他的访问企图则被挂起，只有在有用户退出对此页面的访问后才有可能进入。 事件（Event） 事件对象也可以通过通知操作的方式来保持线程的同步。并且可以实现不同进程中的线程同步操作。 信号量包含的几个操作原语： CreateEvent（） 创建一个信号量 OpenEvent（） 打开一个事件 SetEvent（） 回置事件 WaitForSingleObject（） 等待一个事件 WaitForMultipleObjects（）　　　　　　　　 等待多个事件 WaitForMultipleObjects 函数原型： WaitForMultipleObjects（ IN DWORD nCount, // 等待句柄数 IN CONST HANDLE *lpHandles, //指向句柄数组 IN BOOL bWaitAll, //是否完全等待标志 IN DWORD dwMilliseconds //等待时间 ） 参数nCount指定了要等待的内核对象的数目，存放这些内核对象的数组由lpHandles来指向。fWaitAll对指定的这nCount个内核对 象的两种等待方式进行了指定，为TRUE时当所有对象都被通知时函数才会返回，为FALSE则只要其中任何一个得到通知就可以返回。 dwMilliseconds在这里的作用与在WaitForSingleObject（）中的作用是完全一致的。如果等待超时，函数将返回 WAIT_TIMEOUT。 //事件数组 HANDLE global_Events[2]; // 共享资源 char global_Array[256]; void InitializeArray() { for(int i = 0;iSetWindowText(""); for(int i = 0;iSetWindowText(global_Array); Sleep(10); } //回置事件 SetEvent(global_Events[0]); return 0; } UINT Global_ThreadTwo(LPVOID pParam) { CEdit *ptr=(CEdit *)pParam; ptr->SetWindowText(""); for(int i = 0;iSetWindowText(global_Array); Sleep(10); } //回置事件 SetEvent(global_Events[1]); return 0; } UINT Global_ThreadThree(LPVOID pParam) { CEdit *ptr=(CEdit *)pParam; ptr->SetWindowText(""); //等待两个事件都被回置 WaitForMultipleObjects(2, global_Events, true, INFINITE); for(int i = 0;iSetWindowText(global_Array); Sleep(10); } return 0; } void CEventDlg::OnBnClickedButtonStart() { for (int i = 0; i ResumeThread(); //Start the second Thread CWinThread *ptrTwo = AfxBeginThread(Global_ThreadTwo, &m_Two, THREAD_PRIORITY_NORMAL, 0, CREATE_SUSPENDED); ptrTwo->ResumeThread(); //Start the Third Thread CWinThread *ptrThree = AfxBeginThread(Global_ThreadThree, &m_Three, THREAD_PRIORITY_NORMAL, 0, CREATE_SUSPENDED); ptrThree->ResumeThread(); // TODO: Add your control notification handler code here } 事件可以实现不同进程中的线程同步操作，并且可以方便的实现多个线程的优先比较等待操作，例如写多个WaitForSingleObject来代替WaitForMultipleObjects从而使编程更加灵活。 程序运行结果 总结： 1． 互斥量与临界区的作用非常相似，但互斥量是可以命名的，也就是说它可以跨越进程使用。所以创建互斥量需要的资源更多，所以如果只为了在进程内部 是用的话使用临界区会带来速度上的优势并能够减少资源占用量。因为互斥量是跨进程的互斥量一旦被创建，就可以通过名字打开它。 2． 互斥量 （Mutex），信号灯（Semaphore），事件（Event）都可以被跨越进程使用来进行同步数据操作，而其他的对象与数据同步操作无关，但对于进 程和线程来讲，如果进程和线程在运行状态则为无信号状态，在退出后为有信号状态。所以可以使用WaitForSingleObject来等待进程和线程退 出。 3． 通过互斥量可以指定资源被独占的方式使用，但如果有下面一种情况通过互斥量就无法处理，比如现在一位用户购买了一份三个并发访问 许可的数据库系统，可以根据用户购买的访问许可数量来决定有多少个线程/进程能同时进行数据库操作，这时候如果利用互斥量就没有办法完成这个要求，信号灯 对象可以说是一种资源计数器。 疑问： 在 Linux 上，有两类信号量。第一类是由 semget/semop/semctl API 定义的信号量的 SVR4（System V Release 4）版本。第二类是由 sem_init/sem_wait/sem_post/interfaces 定义的 POSIX 接口。 它们具有相同的功能，但接口不同。 在2.4.x内核中，信号量数据结构定义为(include/asm/semaphore.h)。 但是在 Linux中没有对互斥量的具体提法，只是看到说互斥量是信号量的一种特殊情况，当信号量的最大资源数=1同时可以访问共享资源的线程数=1 就是互斥量了。临界区的定义也比较模糊。没有找到用事件处理线程/进程同步互斥的操作的相关资料。在Linux下用GCC/G++编译标准C++代码，信 号量的操作几乎和Windows下VC7的编程一样，不用改多少就顺利移植了，可是互斥量，事件，临界区的Linux移植没有成功。

Delphi多线程问题

{注意哦，你的两个线程用的同一个变量装它们的句柄，这样是不对地,出错地原因是因为循环操作可视控件的时候，如果不排队，会出现同时访问的情况,最好是可以使用类的方式来使用线程}
unit Unit1;

interface

uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls;

type
TForm1 = class(TForm)
Edit1: TEdit;
Edit2: TEdit;
Button1: TButton;
Button2: TButton;
procedure Button1Click(Sender: TObject);
procedure Button2Click(Sender: TObject);
// procedure FormCreate(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;

var
Form1: TForm1;
hloopHandle:Thandle ; //线程 句柄
dloopThreadID:DWORD ; //线程 id
//================
lpHandles:Thandle;
lpTheradID:DWORD;
function doloop(P:pointer):Longint;stdcall;
Function StartEvent(S:pointer):Longint;stdcall;
implementation

{$R *.dfm}

//按钮一
procedure TForm1.Button1Click(Sender: TObject);
begin
hloopHandle:= CreateThread(nil,0,@doloop,nil,0,dloopThreadID);
if hloopHandle=0 then
begin
messagebox(Handle,'Didn’t Create a Thread',nil,MB_OK);
abort;
end;
end;

//按钮二
procedure TForm1.Button2Click(Sender: TObject);
begin
lpHandles:= CreateThread(nil,0,@StartEvent,nil,0,lpTheradID);
if lpHandles=0 then
begin
messagebox(Handle,'Didn’t Create a Thread',nil,MB_OK);
abort;
end;
end;


//线程处理函数一
function doloop(P:pointer):integer;stdcall;
var
i:integer;
begin
for i:=0 to 100000 do
begin
form1.Edit1.Text:=inttostr(i);
sleep(100);
end;
end;

//==================================
//线程处理函数二
Function StartEvent(S:pointer):integer;stdcall;
var
c:integer;
begin
for c:=0 to 100000 do
begin
form1.Edit2.Text:=inttostr(c);
sleep(100);
end;
end;

end.

Delphi怎样实现多线程

多线程其实非常简单，DELPHI有多线程的类，你添加即可使用，但是我喜欢自己调用API，方法如下：

定义一个函数或者过程，这个函数就是线程要执行的内容，然后调用API就可以不断创建线程，每个线程都单独的执行那个函数，执行完毕线程就自动关闭，下面是我程序里面的部分代码：

{下面这个就是线程过程，我的线程传递一个参数，建立的SOCKET}
procedure ClientThread(var sock:TSOCKET); stdcall;
var ……;
begin
……
end;

{下面是主程序建立服务，等待连接，连接后调用线程进行处理的代码}
repeat
iAddrSize := sizeof(client);
sClient := accept(sListen, @client, @iAddrSize);
if sClient=INVALID_SOCKET then
begin
SocketErrorMsg(sClient, 'accept() fail');
break;
end;
writeln('Accepted client: ',inet_ntoa(client.sin_addr),':',ntohs(client.sin_port),' sock=',sClient);
hThread := CreateThread(nil, $1000, @ClientThread, @sClient, 0, dwThreadId);
if hThread=0 then
begin
writeln('CreateThread() fail:',GetLastError);
break;
end;
CloseHandle(hThread);
until false;