无法定位程序输入点MakeCriticalSectionGlobal于动态链接库Kernel32.dll上

个人觉得是不专业的人靠查字典翻译的.

int a,b;critical section是信号量我的使法是：CRITICAL_SECTION cs;使用前先要初始化：InitializeCriticalSection(&cs);EnterCriticalSection(&cs);a=b;在此期间a、b不能被别的线程等进行操作LeaveCriticalSection(&cs);用后要删除：DeleteCriticalSection(&cs);

对于HTTP协议，默认的超时时间是120秒（可以在LoadRunner中修改），客户端发送一个请求到服务器端，如果超过120秒服务器端还没有返回结果，则出现超时错误。解决办法：首先在运行环境中对超时进行设置，默认的超时时间可以设置长一些，再设置多次迭代运行，如果还有超时现象，需要在"Runtime Setting">"Internet Protocol：Preferences">"Advanced"区域中设置一个"winlnet replay instead of sockets"选项，再回放是否成功。

那你就是和我一样把cs6安装在了XP下了吧，cs6已经不支持xp了。

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_MACHINESystemCurrentControlSetControlSession 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); }

临界区 是什么 一般就是指相对于外界条件自身会发生一定的变化，在这种量变积累到发生质变的时候，这一刻的条件就叫做临界条件，也叫临界点。 比如，常压下的水，零度就是变冰的临界点。或者说零度、常压是临界条件。 什么是临界区 临界区指的是一个访问共用资源(例如:共用设备或是共用存储器)的程序片段，而这些共用资源又无法同时被多个线程访问的特性。当有线程进入临界区段时，其他线程或是进程必须等待(例如:bounded waiting 等待法)，有一些同步的机制必须在临界区段的进入点与离开点实现，以确保这些共用资源是被互斥获得使用，例如:semaphore。只能被单一线程访问的设备，例如:打印机。 临界资源和临界区什么意思？ 1、什么是临界区？答：每个进程中访问临界资源的那段程序称为临界区（临界资源是一次仅允许一个进程使用的共享资源）。每次只准许一个进程进入临界区，进入后不允许其他进程进入。 2、进程进入临界区的调度原则是： ①如果有若干进程要求进入空闲的临界区，一次仅允许一个进程进入。②任何时候，处于临界区内的进程不可多于一个。如已有进程进入自己的临界区，则其它所有试图进入临界区的进程必须等待。③进入临界区的进程要在有限时间内退出，以便其它进程能及时进入自己的临界区。④如果进程不能进入自己的临界区，则应让出CPU，避免进程出现“忙等”现象。 操作系统中的临界区是什么 t; #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. "); printf ("P0 is going to leave critical section. "); flag[0]=false; printf ("P0 is out of critical section. "); } } void P1() { while(true) { flag[1]=true; turn = 0; while(flag[0]&&turn==0) ; printf ("P1 is in critical section. "); printf ("P1 is going to leave critical section. "); flag[1]=false; printf ("P1 is out of critical section. "); } } 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系统下实现 6. 临界区是指并发进程中访问共享变量的()段. A,管理信息 B,信息存储 C,数据 D,程序 D.程序 临界区是指并发进程中访问共享变量的(程序)段 临界区是指并发进程中访问共享变量的什么段? 临界区是指并发进程中访问共享变量的程序段 临界区问题的解决方案必须满足的三个要求是什么 进程进入临界区要满足一定的条件，以保证临界资源的安全使用，系统的正常运行，即对临界区的管理就遵循以下三个原则：（1）当有若干进程要求进入它们的临界区时，应在有限时间内使一进程进入临界区。 TC的临界区是什么？ 也就是多线程的临界区，用来保护公有数据，一个线程在访问时另一个只能等待其完成后才能操作。 简述什么是线程同步机制和临界区管理 临界区的基本概念 临界区：在同一个进程内的多个线程之间通过原子方式实现共享资源的串行化读写。 临界区相关函数 CRITICAL_SECTION cs; ::InitializeCriticalSection(&cs); ::EnterCriticalSection(&cs); ::LeaveCriticalSection(&cs); ::DeleteCriticalSection(&cs); 临界区编程实例 实例一：临界区基本使用方法 输出结果（注掉13,17,没有进行临界区同步）: 输出结果（临界区同步）: 实例二：使用临界区对象创建自动锁 CriticalSection：封装 Windows CRICITAL_SECTION 用户对象 AutoLock：封装CriticalSection的操作，让它进入一个Scope的时候自动加锁，离开一个Scope的时候自动解锁 对临界区管理的基本原则是什么? ①有则等待，无则进入。②临界区内有且只有一个进程。③进程进入临界区后必须在有限时间内退出。④如果进程不能进入自己的临界区，则应让出CPU，避免出现“忙等”。

#include <pthread.h> #include <stdio.h> #include <unistd.h> #include <stdlib.h> #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. "); printf ("P0 is going to leave critical section. "); flag[0]=false; printf ("P0 is out of critical section. "); } } void P1() { while(true) { flag[1]=true; turn = 0; while(flag[0]&&turn==0) ; printf ("P1 is in critical section. "); printf ("P1 is going to leave critical section. "); flag[1]=false; printf ("P1 is out of critical section. "); } } 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系统下实现

lz的代码在我这里运行没问题虚拟机win2003+vs2008

　　多次调用，会产生多个临界区，其中的参数作为返回值　　所以你调用多次DeleteCriticalSection（）也不会全部释放掉你初始化的所有临界区，这样的话会有内存或者是资源泄露

此文件本质上是dll运行库的一部分，丢失、缺失此类文件都是dll运行库的问题，而不是游戏本身的问题。所以重新下游戏肯定是没有用的。　　并且，有些人建议的重装系统大法也是没用的（指原版系统，换系统除外）。因为这些所谓的dll丢失，绝大部分都并不是真的“丢失”，而是原版系统本身确实就没有自带。　　建议使用dll修复工具，解压之后打开主程序点击“修复”按钮，稍等即可解决。关于附件：dll运行库修复工具是很容易搜到下载的，也可以直接下载我附件(上传附件仅仅是为了下载方便，也可以直接搜索下载)，附件免费下载，不要积分。7z、rar、zip文件要用解压缩软件打开，x86版就是32位版，请不要再问出“为什么只有86位版”之类搞笑的问题。

具体错误是贴出来。函数 EnterCriticalSection要和LeaveCriticalSection成对出现才可以。而且在使用EnterCriticalSection，必须InitializeCriticalSection进行初始化InitializeCriticalSection(&cs);//初始化临界区

给你看看一些高手的回复了。有一个叫做services.exe（大家都知道其实是系统程序）的程序被设为了开机自启动程序，当它启动后，会从一个叫KERNEL32.dll的动态链接库文件中调用一个叫做Lpkpresent的函数，但是，它调用失败了。于是就出现了这样的提示。 services.exe本来是系统的一部分，用于对系统注册表中进行进一步的配置。但从你的情况来看，你很可能是中了病毒。目前有“中国黑客”一类的病毒会将自己伪装（或加载）为services.exe来随系统启动。 机器可以已经中毒，建议杀毒 如果技术够高，复制别人机子的kernel32.dll 到除了C盘的其他盘,重启进入dos,把C:WINDOWS下面的kernel32.dll删除,复制干净的到C:WINDOWS下面,重启进入windows,就可以了.我试过网上好多方法都杀不掉,我就这样杀掉了.试试 实在不会的话 用杀毒软件吧可以看看 介绍 http://zhidao.baidu.com/question/2830444.html

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

　　TestAndSet　　一个执行单元要想访问被自旋锁保护的共享资源，必须先得到锁，在访问完共享资源后，必须释放锁。如果在获取自旋锁时，没有任何执行单元保持该锁，那么将立即得到锁；如果在获取自旋锁时锁已经有保持者，那么获取锁操作将自旋在那里，直到该自旋锁的保持者释放了锁。由此可以看出，自旋锁是一种比较低级的保护数据结构或代码片段的原始方式，这种锁可能存在两个问题：　　死锁。试图递归地获得自旋锁必然会引起死锁：递归程序的持有实例在第二个实例循环，以试图获得相同自旋锁时，不会释放此自旋锁。在递归程序中使用自旋锁应遵守下列策略：递归程序决不能在持有自旋锁时调用它自己，也决不能在递归调用时试图获得相同的自旋锁。此外如果一个进程已经将资源锁定，那么，即使其它申请这个资源的进程不停地疯狂“自旋”,也无法获得资源，从而进入死循环。　　过多占用cpu资源。如果不加限制，由于申请者一直在循环等待，因此自旋锁在锁定的时候,如果不成功,不会睡眠,会持续的尝试,单cpu的时候自旋锁会让其它process动不了. 因此，一般自旋锁实现会有一个参数限定最多持续尝试次数. 超出后, 自旋锁放弃当前time slice. 等下一次机会。

安装下libwinpthread 建议你用msys2或者mingw64，安装这个 mingw-w64-i686-libwinpthread

重启按住F8键，出现开机菜单时，选择最后一次正确配置，回车试。不行的话，你再选一下安全模式，进入杀毒、360卫士扫描，处理完，重启试试。如不行重装系统。

暂停中断。程序运行到这说明有中断请求，这时需要对这个中断进行处理，为了防止又有中断进来引起冲突，就先暂停中断。个人理解。

无法定位动态链接库的原因1.病毒木马导致的，比较典型的病毒是绑架类木马，它是一种新型破坏性极强的木马与传统病毒不同，它是通过绑架系统文件dll实现开机启动，该木马主要表现，2.升级某个软件导致的。重装该软件即可解决该问题。3.自己误操作造成的。无法定位程序输入点的修复方案：软件修复：下载安装金山卫士，进入主界面进入【查杀木马】然后点击【快速扫描】即可手动修复无法定位程序输入点于动态链接库上方法1.通过互联网上搜索下载下载你所需dll，把你所想要的dll输入到搜索框里去，注意搜索时一定要开启金山卫士的上网安全浏览功能，以免因无法定位程序输入点的问题导致进入挂马或者钓鱼站点引起电脑中毒。2.重启电脑快捷键f2或者f8进入安全模式3.将缺少的dll放到C:windowssystem32即可

这里下载KERNEL32.dll后复制到C:WINDOWSsystem32http://www.filediag.com/dll/exe/kernel32.dll.html文件描述:WindowsNTBASEAPIClientDLL/WindowsNT基本API客户端DLL

同问，求办法

GlobalData: array[1..Maxsize] of integer;

会循环尝试4000次获取锁，如果4000次后还没成功获取就会休眠线程，等别人释放锁以后再唤醒。说老实话4000是不是也有点太多了……

v文章名称：修复系统无法启动登陆，系统程序"lsass.exe"弹出错误提示"无法定位程序输入点LdrsetSessionName于动态链接库mfc40u.dll上"的方法文章类型：系统修复、病毒查杀说明： 系统无法正常登陆，在启动时系统程序“lsass.exe”会弹出错误提示：“无法定位程序输入点 LdrsetSessionName 于动态链接库 mfc40u.dll 上。”或“没有找到 mfc40u.dll 组件，重新安装应用程序可能会修复此问题。”等信息的修复方法。------------------------------------------------------------------------------------------------------------------------------------------------介绍： 系统程序“lsass.exe”弹出错误“无法定位程序输入点 LdrsetSessionName 于动态链接库 mfc40u.dll 上。”这个提示是由于系统被病毒破坏而产生的。是系统程序“lsass.exe”进程启动时弹出来的错误提示信息，真正的系统程序“lsass.exe” 进程中是不会有这种提示信息的。之所以会弹出该提示，是因为病毒修改了系统“lsass.exe”程序的输入表(在输入表的尾部多加了一条调用信息 “LdrsetSessionName”、“mfc40u.dll”)，同时病毒又使用自身释放出来的恶意DLL组件覆盖了系统本身的DLL组件 “mfc40u.dll”(系统内原本就有这个DLL组件的)。当杀毒软件或安全软件发现了被病毒程序破坏的系统DLL组件“mfc40u.dll”(系统原DLL组件的功能是MFC的部分函数库，被病毒覆盖后的DLL组件的功能是木马下载器)后，就给强行删除掉了，但没有去修复系统程序 “lsass.exe”文件的输入表，也没有还原被病毒破坏的系统DLL组件“mfc40u.dll”文件，所以出现了上边的错误提示信息。 病毒是利用磁盘过滤驱动去读写真实磁盘中的数据，然后去破坏系统“lsass.exe”和“mfc40u.dll”文件的。所以，不管系统 “lsass.exe”和“mfc40u.dll”程序有没有在运行，都会被病毒破坏掉。该病毒使用了类似于“古老的机器狗病毒穿系统还原的设计原理”，并没有去破坏您系统的注册表中的数据信息。所以在网络上见很多人提出使用“重新注册系统‘mfc40u.dll"DLL组件的方法是不对的”，可能会对系统造成更大的破坏。要对症下药，不然很可能会越医越病！！------------------------------------------------------------------------------------------------------------------------------------------------信息：“C:” = “这里的C盘为系统盘”“lsass.exe” = “C:WINDOWSsystem32lsass.exe”“mfc40u.dll” = “C:WINDOWSsystem32mfc40u.dll”上述二个文件一般都可以在系统“C:WINDOWSsystem32dllcache”目录下找到正常完好的系统备份文件。------------------------------------------------------------------------------------------------------------------------------------------------修复方法步骤(经过实际测试绝对有效)：-------------------------------------一、系统可以启动登陆的修复方法：(转载请注明出自Coderui的博客，谢谢)1：把系统程序“lsass.exe”文件和系统DLL组件程序“mfc40u.dll”文件同时改名，Windows系统是支持运行着的程序改名的。(如果您能终止掉系统程序“lsass.exe”和DLL组件“mfc40u.dll”的运行也可以)。2：复制一个正常的系统程序“lsass.exe”文件保存为“C:WINDOWSsystem32lsass.exe”文件。3：复制一个正常的系统DLL组件程序“mfc40u.dll”文件保存为“C:WINDOWSsystem32mfc40u.dll”文件。4：按照上边的1-3步骤操作完毕后，重新启动一次计算机，一切修复完毕。5：系统修复完毕后，要使用杀毒软件去查杀病毒。因为该病毒为木马下载器，它可能已经在您的计算机系统中安装了其它恶意程序(20款以上)。--------------------------------------------------------------------------二、系统无法启动登陆的修复方法：(转载请注明出自Coderui的博客，谢谢)1：使用PE盘或DOS盘启动系统(这种情况下，安全模式是无法登陆的)。2：复制一个正常的系统程序“lsass.exe”文件保存为“C:WINDOWSsystem32lsass.exe”文件。3：复制一个正常的系统DLL组件程序“mfc40u.dll”文件保存为“C:WINDOWSsystem32mfc40u.dll”文件。4：按照上边的1-3步骤操作完毕后，重新启动一次计算机，一切修复完毕。5：系统修复完毕后，要使用杀毒软件去查杀病毒。因为该病毒为木马下载器，它可能已经在您的计算机系统中安装了其它恶意程序(20款以上)。--------------------------------------------------------------------------注意：上述三个文件一般都可以在系统“C:WINDOWSsystem32dllcache”目录下找到正常完好的系统备份文件。如果实在没有找到的话，可以去同一个版本的其它计算机系统中拷贝。最好是断开网络修复系统，因为该病毒为木马下载器，它会连接网络向您的计算机中安装20多款其它恶意程序(如网络游戏盗号木马等)。因为该病毒并没有去破坏或修改您系统中的注册表，请您不要去重新注册系统DLL组件“mfc40u.dll”，不然可能会带去不必要的麻烦。-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------这个病毒我们已经捕捉到了(转载请注明出自Coderui的博客，谢谢)，并做了分析和处理。上述方法在真实机器上测试修复通过，和大家分享下，希望可以帮助处于水深火热中的朋友们，这样大家就省去重新安装操作系统的麻烦了。

这个是因为缺少MSVCR100.DLL导致的。解决方法：建议用【百度电脑专家】的”VS2010运行时库缺失“修复下，修复链接：http://zhuanjia.baidu.com/detail?pid=1074#top修复后刷新下电脑或者重启下；如果修复不成功，建议手动下载相匹配的msvcp100.dll文件放到相应目录C:WindowsSystem32下或者提示错误软件所在文件下。若问题依旧，可以在【百度电脑专家】提交您的问题。以下是【百度电脑专家】的下载链接，希望可以帮到您~

楼主，你的程序也太乱了吧。Mutex的用法也很简单，在main函数里创建一个Mutex，在线程里进入一段代码前用WaitForSIngleObject，退出代码后用ReleaseMutex就行了。下面是从static int count=5开始的程序，前面的不用改。static int count=5;static HANDLE h1;static HANDLE h2;HANDLE g_hMutex;void func1();void func2();int _tmain(int argc, TCHAR* argv[], TCHAR* envp[]){int nRetCode = 0;DWORD dwThreadID1,dwThreadID2;g_hMutex = CreateMutex(NULL, FALSE, NULL);h1=CreateThread((LPSECURITY_ATTRIBUTES)NULL, 0, (LPTHREAD_START_ROUTINE)func1, (LPVOID)NULL, 0,&dwThreadID1);if(h1==NULL) printf("Thread1 create Fail! ");elseprintf("Thread1 create Success! ");h2=CreateThread((LPSECURITY_ATTRIBUTES)NULL, 0, (LPTHREAD_START_ROUTINE)func2, (LPVOID)NULL, 0,&dwThreadID2);if(h1==NULL) printf("Thread2 create Fail! ");elseprintf("Thread2 create Success! ");Sleep(1000);CloseHandle(h1);CloseHandle(h2);ExitThread(0);return nRetCode;}void func2(){int r2;WaitForSingleObject(g_hMutex, INFINITE);r2=count;_sleep(100);r2=r2+1;count=r2;printf("count in func2=%d ",count);ReleaseMutex(g_hMutex);}void func1(){int r1;WaitForSingleObject(g_hMutex, INFINITE);r1=count;_sleep(500);r1=r1+1;count=r1;printf("count in func1=%d ",count);ReleaseMutex(g_hMutex);}

我的也是，不过我的是出现dsound.dll和kernel32.dll后来用金山网盾都修复了百度一下金山网盾，下载安装，使用里面的一键修复即可解决

坐等神回复

我建议你使用金山毒霸，因为我也有你这样的经历，真的。经过朋友的推荐，金山毒霸会把丢失的DLL文件全部查出，然后对你的电脑分析，找出合适的DLL文件。金山毒霸官方网址：www.duba.net

Delphi同步互斥总结 多个线程同时访问一个共享资源或数据时，需要考虑线程同步,Synchronize()是在一个隐蔽的窗口里运行，如果在这里你的任务很繁忙，你的主窗口会阻塞掉；Synchronize()只是将该线程的代码放到主线程中运行，并非线程同步。 临 界区是一个进程里的所有线程同步的最好办法，他不是系统级的，只是进程级的，也就是说他可能利用进程内的一些标志来保证该进程内的线程同步，据 Richter说是一个记数循环；临界区只能在同一进程内使用；临界区只能无限期等待，不过2k增加了TryEnterCriticalSection函 数实现0时间等待。 互斥则是保证多进程间的线程同步，他是利用系统内核对象来保证同步的。由于系统内核对象可以是有名字的，因此多个 进程间可以利用这个有名字的内核对象保证系统资源的线程安全性。互斥量是Win32 内核对象，由操作系统负责管理；互斥量可以使用WaitForSingleObject实现无限等待，0时间等待和任意时间等待。常见的线程同步方法如下：1. 临界区临界区是一种最直接的线程同步方式。所谓临界区，就是一次只能由一个线程来执行的一段代码。如果把初始化数组的代码放在临界区内，另一个线程在第一个线程处理完之前是不会被执行的。使用方法如下：//在窗体创建中InitializeCriticalSection(Critical1)//在窗体销毁中DeleteCriticalSection(Critical1)//在线程中EnterCriticalSection(Critical1)……保护的代码LeaveCriticalSection(Critical1)2. 互斥互斥非常类似于临界区，除了两个关键的区别：首先，互斥可用于跨进程的线程同步。其次，互斥能被赋予一个字符串名字，并且通过引用此名字创建现有互斥对象的附加句柄。 临界区与事件对象(比如互斥对象)的最大的区别是在性能上。临界区在没有线程冲突时，要用10 ~ 15个时间片，而事件对象由于涉及到系统内核要用400~600个时间片。Mutex（互斥对象），是用于串行化访问资源的全局对象。我们首先设置互斥对象，然后访问资源，最后释放互斥对象。在设置互斥对象时，如果另一个线程（或进程）试图设置相同的互斥对象，该线程将会停下来，直到前一个线程（或进程）释放该互斥对象为止。注意它可以由不同应用程序共享。使用方法如下：//在窗体创建中hMutex:=CreateMutex(nil,false,nil)//在窗体销毁中CloseHandle(hMutex)//在线程中WaitForSingleObject(hMutex,INFINITE)……保护的代码ReleaseMutex(hMutex)3. 信号量另一种使线程同步的技术是使用信号量对象。它是在互斥的基础上建立的，但信号量增加了资源计数的功能，预定数目的线程允许同时进入要同步的代码。可以用CreateSemaphore()来创建一个信号量对象，因为只允许一个线程进入要同步的代码，所以信号量的最大计数值(lMaximumCount)要设为1。其实Mutex就是最大计数为一的Semaphore。使用方法如下：//在窗体创建中hSemaphore:= CreateSemaphore(nil,lInitialCount,lMaximumCount,lpName)//在窗体销毁中CloseHandle(hSemaphore)//在线程中WaitForSingleObject(hSemaphore,INFINITE)……保护的代码ReleaseSemaphore(hSemaphore, lReleaseCount, lpPreviousCount)4.WaitForSingleObject函数的返值：WAIT_ABANDONED指定的对象是互斥对象，并且拥有这个互斥对象的线程在没有释放此对象之前就已终止。此时就称互斥对象被抛弃。这种情况下，这个互斥对象归当前线程所有，并把它设为非发信号状态；WAIT_OBJECT_0 指定的对象处于发信号状态；WAIT_TIMEOUT等待的时间已过，对象仍然是非发信号状态；Delphi 常用的临界区对象TCriticalSection(Delphi) 、TRtlCriticalSectionTRtlCriticalSection 是一个结构体，在windows单元中定义； 是InitializeCriticalSection，EnterCriticalSection，LeaveCriticalSection, DeleteCriticalSection 等这几个kernel32.dll中的临界区操作API的参数；TCriticalSection是在SyncObjs单元中实现的类，它对上面的那些临界区操作API函数进行了了封装，简化并方便了在Delphi的使用；如TCriticalSection.Create,TCriticalSection.Enter, TcriticalSection.Leave等;通过调用上面响应的API函数实现。线程同步的多种办法中，使用临界区最简单，也是效率最高的办法(CPU占用时间最少)使用临界区代码如下：先声明一个TRTLCriticalSection类型的全局变量varMyCs:TRTLCriticalSection;在程序开始或建立线程之前，初始化InitializeCriticalSection(MyCs);//初始化临界区在程序结束或所有线程结束后，删除它DeleteCriticalSection(MyCs);//删除临界区再在线程中要同步的地方加入EnterCriticalSection(MyCs); //进入临界区try//程序代码finallyLeaveCriticalSection(MyCs); //离开临界区end;补充今天遇到的关于Application.ProcessMessages同步的问题：有一个函数Fn按执行顺序可分为A->B->C3大块，其中B块有要绘制各种窗口界面的操作很复杂且耗时较长，并且里面用到了Application.ProcessMessages,程序运行测试时发现如果在Fn执行B绘制窗口的过程没结束时又调用Fn函数去绘制其它窗口就可能会导致程序崩溃，一开始尝试用TcriticalSection变量解决，完全没用，最后用增加一个全局变量的方法解决：定义一个全局Boolean型变量flag，设定初始值为True，改造Fn函数的逻辑为A-> if flag thenBeginFlag:=False;B;Flag:=True;End;->C问题成功解决。顺便总结Application.ProcessMessages的作用：运行一个非常耗时的循环，那么在这个循环结束前，程序可能不会响应任何事件，按钮没有反应，程序设置无法绘制窗体，看上去就如同死了一样，这有时不是很方便，例如于终止循环的机会都没有了，又不想使用多线程时,这时你就可以在循环中加上这么一句，每次程序运行到这句时，程序就会让系统响应一下消息，从而使你有机会按按钮，窗体有机会绘制。所起作用类似于VB中DoEvent方法.调用ProcessMessages来使应用程序处于消息队列能够进行消息处理，ProcessMessages将Windows消息进行循环轮转，直至消息为空，然后将控制返回给应用程序。注示：仅在应用程序调用ProcessMessages时勿略消息进程效果，而并非在其他应用程序中。在冗长的操作中，调用ProcessMessages周期性使得应用程序对画笔或其他信息产生回应。ProcessMessages不充许应该程序空闲，而HandleMessage则然.使用ProcessMessages一定要保证相关代码是可重入的，如果实在不行也可按我上面的方法实现同步。

这个问题可以尝试用360安全卫士进行修复的，它里面的系统修复工具很好用的。能解决很多问题的

我的理解是每一个线程都有一个独立的对象就不存在线程安全问题，也没有了加锁的必要

这个 可能跟你的系统有关 只能安装不能打开 现在的PSCC最高也是用WIN7的 呵呵 XP系统无法兼容 还是先把系统升了级 再去安装 就没问题了

你是说windows下么？ 那是不可能的。windows是一个非实时的，抢占式系统，cpu采用轮询的方式，调度所有进程。不论你任务优先级多高，也会被低优先级的进程打断。或者被硬中断的响应函数打断。不论你任务优先级多低，也有可能被cpu调度并执行。当然轮到你干活的时候，你可以主动放弃cpu时间。（比如Sleep,waitSignalObject)vxwork，ucos或者linux（实时版）的操作系统下编程，是绝对会按照你分配的优先级工作的即，高优先级的任务（进程） 只要不放弃cpu的使用。那它可以一直不被打断的工作。相应的，低优先级的任务（进程）即使已经被执行，也可能被高优先级的任务无情的打断。

注意一下线程同步!

下面那个最佳回答，还赞最多的，逻辑就不通，你能把那个ABC用双代号表示出来吗？A的紧后工作是BC，BC都是平行工作了，又怎么能出现B的紧后工作是C，看似在单代号里能画，其它逻辑不通。关于单代号和双代号的区别，大家都知道，单代号用结点表示工作，双代号用线表示工作。也就是说单代号的点=双代号的线；双代号的点=单代号的线。在双代号中，大家都知道，全部由关键结点组成的线路不一定是关键工作。同理单代号中以线来判断的也存在同样的问题。

你好，解释如下：临界区是一种轻量级机制，在某一时间内只允许一个线程执行某个给定代码段。通常在多线程修改全局数据时会使用临界区。事件、信号量也用于多线程同步，但临界区与它们不同，并不总是执行向内核模式的切换，这一转换成本昂贵。要获得一个未占用临界区，事实上只需要对内存做出很少的修改，其速度非常快。只有在尝试获得已占用临界区时，它才会跳至内核模式。这一轻量级特性的缺点在于临界区只能用于对同一进程内的线程进行同步。临界区由 WINNT.H 中所定义的 RTL_CRITICAL_SECTION 结构表示。 WINBASE.H 后您会发现：typedef RTL_CRITICAL_SECTION CRITICAL_SECTION;操作临界区的API函数有：（1）初始化临界区InitializeCriticalSection（2）进入临界区EnterCriticalSection（3）离开临界区LeaveCriticalSection（4）删除临界区DeleteCriticalSection在临界区未被使用的理想情况中，对 EnterCriticalSection 的调用非常快速，因为它只是读取和修改用户模式内存中的内存位置。所阻止的线程以内核模式等待，在该临界区的所有者将其释放之前，不能对这些线程进行调度。如果有多个线程被阻止于一个临界区中，当另一线程释放该临界区时，只有一个线程获得该临界区。RTL_CRITICAL_SECTION 结构一个进程的临界区是保存于一个链表中，并且可以对其进行枚举。实际上，WINDBG 支持 !locks 命令，这一命令可以列出目标进程中的所有临界区。RTL_CRITICAL_SECTION 结构如下：struct RTL_CRITICAL_SECTION{ PRTL_CRITICAL_SECTION_DEBUG DebugInfo; LONG LockCount; LONG RecursionCount; HANDLE OwningThread; HANDLE LockSemaphore; ULONG_PTR SpinCount;};以下各段对每个字段进行说明。DebugInfo 此字段包含一个指针，指向系统分配的伴随结构，该结构的类型为 RTL_CRITICAL_SECTION_DEBUG。这一结构中包含更多极有价值的信息，也定义于 WINNT.H 中。LockCount 这是临界区中最重要的一个字段。它被初始化为数值 -1；此数值等于或大于 0 时，表示此临界区被占用。当其不等于 -1 时，OwningThread 字段包含了拥有此临界区的线程 ID。此字段与 (RecursionCount-1) 数值之间的差值表示有多少个其他线程在等待获得该临界区。RecursionCount 此字段包含所有者线程已经获得该临界区的次数。如果该数值为零，下一个尝试获取该临界区的线程将会成功。OwningThread 此字段包含当前占用此临界区的线程的线程标识符。此线程 ID 与 GetCurrentThreadId 之类的 API 所返回的 ID 相同。LockSemaphore 它是一个内核对象句柄，用于通知操作系统：该临界区现在空闲。操作系统在一个线程第一次尝试获得该临界区，但被另一个已经拥有该临界区的线程所阻止时，自动创建这样一个句柄。应当调用 DeleteCriticalSection（它将发出一个调用该事件的 CloseHandle 调用，并在必要时释放该调试结构），否则将会发生资源泄漏。SpinCount 仅用于多处理器系统。MSDN文档对此字段进行如下说明：“在多处理器系统中，如果该临界区不可用，调用线程将在对与该临界区相关的信号执行等待操作之前，旋转 dwSpinCount 次。如果该临界区在旋转操作期间变为可用，该调用线程就避免了等待操作。”旋转计数可以在多处理器计算机上提供更佳性能，其原因在于在一个循环中旋转通常要快于进入内核模式等待状态。此字段默认值为零，但可以用 InitializeCriticalSectionAndSpinCount API 将其设置为一个不同值。RTL_CRITICAL_SECTION_DEBUG结构如下：struct _RTL_CRITICAL_SECTION_DEBUG{ WORD Type; WORD CreatorBackTraceIndex; RTL_CRITICAL_SECTION *CriticalSection; LIST_ENTRY ProcessLocksList; DWORD EntryCount; DWORD ContentionCount; DWORD Spare[ 2 ];}这一结构由InitializeCriticalSection分配和初始化。它既可以由NTDLL内的预分配数组分配，也可以由进程堆分配。RTL_CRITICAL_SECTION的这一伴随结构包含一组匹配字段，具有迥然不同的角色：有两个难以理解，随后两个提供了理解这一临界区链结构的关键，两个是重复设置的，最后两个未使用。下面是对 RTL_CRITICAL_SECTION 字段的说明。Type 此字段未使用，被初始化为数值 0。CreatorBackTraceIndex 此字段仅用于诊断情形中。在注册表项 HKLMSoftwareMicrosoftWindows NTCurrentVersionImage File Execution OptionsYourProgram 之下是 keyfield、GlobalFlag 和 StackTraceDatabaseSizeInMb 值。注意，只有在运行稍后说明的 Gflags 命令时才会显示这些值。这些注册表值的设置正确时，CreatorBackTraceIndex 字段将由堆栈跟踪中所用的一个索引值填充。在 MSDN 中搜索 GFlags 文档中的短语“create user mode stack trace database”和“enlarging the user-mode stack trace database”，可以找到有关这一内容的更多信息。CriticalSection 指向与此结构相关的 RTL_CRITICAL_SECTION。图 1 说明该基础结构以及 RTL_CRITICAL_SECTION、RTL_CRITICAL_SECTION_DEBUG 和事件链中其他参与者之间的关系。图 1 临界区处理流程ProcessLocksList LIST_ENTRY 是用于表示双向链表中节点的标准 Windows 数据结构。RTL_CRITICAL_SECTION_DEBUG 包含了链表的一部分，允许向前和向后遍历该临界区。本文后面给出的实用工具说明如何使用 Flink（前向链接）和 Blink（后向链接）字段在链表中的成员之间移动。任何从事过设备驱动程序或者研究过 Windows 内核的人都会非常熟悉这一数据结构。EntryCount/ContentionCount 这些字段在相同的时间、出于相同的原因被递增。这是那些因为不能马上获得临界区而进入等待状态的线程的数目。与 LockCount 和 RecursionCount 字段不同，这些字段永远都不会递减。Spares 这两个字段未使用，甚至未被初始化（尽管在删除临界区结构时将这些字段进行了清零）。后面将会说明，可以用这些未被使用的字段来保存有用的诊断值。总结：（1）如果 LockCount 字段有一个不等于 -1 的数值，此临界区被占用，OwningThread 字段包含拥有该临界区的线程的线程标识符。（2）如果 RecursionCount 是一个大于 1 的数值，其告知您所有者线程已经重新获得该临界区多少次（也许不必要）。（3）LockCount 与 RecursionCount 字段中分别包含其初始值 -1 和 0，这一点非常重要。事实上，对于单线程程序，不能仅通过检查这些字段来判断是否曾获得过临界区。但是，多线程程序留下了一些标记，可以用来判断是否有两个或多个线程试图同时拥有同一临界区。（4）在该临界区未被占用时 LockSemaphore 字段中仍包含一个非零值。这表示：在某一时间，此临界区阻止了一个或多个线程。事件句柄用于通知该临界区已被释放，等待该临界区的线程之一现在可以获得该临界区并继续执行。因为 OS 在临界区阻止另一个线程时自动分配事件句柄，所以如果您在不再需要临界区时忘记将其删除，LockSemaphore 字段可能会导致程序中发生资源泄漏。（5）在多线程程序中可能遇到的另一状态是 EntryCount 和 ContentionCount 字段包含一个大于零的数值。这两个字段保存有临界区对一个线程进行阻止的次数。在每次发生这一事件时，这两个字段被递增，但在临界区存在期间不会被递减。这些字段可用于间接确定程序的执行路径和特性。例如，EntryCount 非常高时则意味着该临界区经历着大量争用，可能会成为代码执行过程中的一个潜在瓶颈。（6）可以通过RTL_CRITICAL_SECTION_DEBUG 中的LIST_ENTRY 遍历进程中的临界区，Flink=NULL为表头，Blink=NULL为表尾。（7）利用RTL_CRITICAL_SECTION 的 Spare 字段可以区分我们定义的临界区和系统定义的临界区。

原因：编译的release版本，在XP下运行报错误“无法定位程序输入点InitializeCriticalSectionEx 于动态链接库kernel32.dll”。解决步骤：1、请先升级到最新Update4。2、将工程（包括用到的DLL工程也需设置）做如下设置：项目——属性——配置属性——常规——平台工具集——Visual Studio 2012 - Windows XP (v110_xp)项目——属性——配置属性——常规——MFC的使用——在静态库中使用 MFC。项目——属性——配置属性——常规——ATL的使用——静态链接到 ATL。平台工具集，必须设置。MFC的使用、ATL的使用结合具体情况。Release版一般设为静态。对计算机软件的维护主要有以下几点:(1)对所有的系统软件要做备份。当遇到异常情况或某种偶然原因，可能会破坏系统软件，此时就需要重新安装软件系统，如果没有备份的系统软件，将使计算机难以恢复工作。(2)对重要的应用程序和数据也应该做备份。(3)经常注意清理磁盘上无用的文件，以有效地利用磁盘空间。(4)避免进行非法的软件复制。(5)经常检测，防止计算机传染上病毒。(6)为保证计算机正常工作，在必要时利用软件工具对系统区进行保护。总之，计算机的使用是与维护分不开的，既要注意硬件的维护，又要注意软件的维护。

安装vc2005和vc2008运行库试试.

+1+1+1+1+1+1

装visual 2010 C++的X86版本，就算你是64位系统，也要装1次32位的这个程序，我也遇到过，装了就好了

l因为以前用这个方法解决过一个朋友的问题,所以将这个答案复制过来了,希望能帮到你首先看看Trade_exe.dll文件在不在机器上，如果在的话，从其他机器上拷一个新的覆盖看看一、可能是你安装了一些不能支持WindowsNT/2000/XP，只能运行于Windows9x系统上的程序所以造成的，遇到这种问题，可以试着搜索一下KERNEL32文件，看是哪个软件安装目录下有这个文件，然后将软件安装目录下的这个文件删除，应该可以解决问题。二、重新安装该程序，无法定位是因为链接库不存在，所以重新安装那个程序。无法定位程序输入点Trade_CheckUnterType于动态连锁库Trade_exe.dll上表示游戏程序需要调用Trade_exe.dll函数库的Trade_CheckUnterType函数，但是你机器上的Trade_exe.dll文件中没有该函数。解决办法：到别的机器上复制一个Trade_exe.dll文件过来！！你的Trade_exe.dll文件可能损坏了。如果不行，在尝试以下办法！你看一下你的direct版本下载个direct9.0装上!!http://58.251.57.67/down?cid=1477F527946ED50131EBED031B6573D8FCF197A2&t=2&fmt=-再用这个试试！！！U盘病毒专杀工具(USBCleaner)V6.0Build20080201下载地址：http://58.251.57.67/down?cid=BD2F8CEDEE717A65BF8ADDBEF4B9E9482A71C0B5&t=2&fmt=-

去网站下个kernel32.dll文件，一定要对应系统的，然后去安全模式下在C盘WINDOWS SYSTEM32里找到kernel32.dll文件随便改个名字 把下载的复制进去就OK了

建议参考一下这几个函数或者直接使用CCriticalSection类InitializeCriticalSection（...）初始化临界区TryEnterCriticalSection（...） 进入临界区EnterCriticalSection（...） 进入临界区LeaveCriticalSection（...） 离开临界区DeleteCriticalSection（...）删除临界区

void CCOMMUNICATIONSet::OnBtnStartcan() //“启动CAN”按钮{ // TODO: Add your control notification handler code here if(m_connect==1) //如果已经连接 { m_connect=0; m_startcanlight.SetIcon(m_hIConGrey1); Sleep(500); GetDlgItem(IDC_EDIT_BTR)->EnableWindow(!m_connect); GetDlgItem(IDC_EDIT_STARTID)->EnableWindow(!m_connect); GetDlgItem(IDC_EDIT_ENDID)->EnableWindow(!m_connect); GetDlgItem(IDC_COMBO_BAUD)->EnableWindow(!m_connect); GetDlgItem(IDC_COMBO_FILTER)->EnableWindow(!m_connect); GetDlgItem(IDC_COMBO_MODE)->EnableWindow(!m_connect); OnSelchangeComboBaud(); OnSelchangeComboFilter(); GetDlgItem(IDC_BTN_STARTCAN)->SetWindowText("启动CAN"); VCI_ResetCAN(m_devtype,m_devind,m_cannum); VCI_CloseDevice(m_devtype,m_devind);// 此函数用以关闭设备。 return; } //如果未连接 VCI_INIT_CONFIG init_config;//定义初始化CAN的数据类型的结构体 int index,mode,cannum,baud; UpdateData(true);//控件的值->变量index=m_ComboIndex.GetCurSel();//设备索引号 mode=m_ComboMode.GetCurSel();//工作模式 cannum=m_ComboCANInd.GetCurSel();//第几路CAN sscanf(m_strBTR, _T("%x"), &baud); m_devind=index;//设备类型 m_cannum=cannum;//第几路CAN UpdateData(false);//变量值->控件显示 init_config.Mode=mode;//模式 //滤波设置 DWORD filterMode=m_ComboFilterMode.GetCurSel();//"滤波模式" if (filterMode!=2) { VCI_FILTER_RECORD filterRecord; filterRecord.ExtFrame=filterMode; UpdateData(TRUE);//控件的值->变量 DWORD IDtemp; IDtemp=atoi(m_strStartID);//"滤波范围起始帧ID"字符转换为整形 //_stscanf_s(m_strStartID, _T("%d"), &IDtemp); filterRecord.Start = IDtemp;//Start:滤波范围的起始帧ID IDtemp=atoi(m_strEndID);//"滤波范围结束帧ID"字符转换为整形 //_stscanf_s(m_strEndID, _T("%d"), &IDtemp); filterRecord.End= IDtemp;//End:滤波范围的结束帧ID VCI_SetReference(m_devtype, m_devind, cannum, 1, &filterRecord);// 设置报文滤波。为1表示操作成功，0表示操作失败 //使滤波表格生效 if (VCI_SetReference(m_devtype, m_devind, cannum, 2, NULL)!=STATUS_OK)//参数类型为2???????????????????? { MessageBox(_T("设置滤波失败!"), _T("警告"), MB_OK | MB_ICONQUESTION); VCI_CloseDevice(m_devtype,index); return; } } m_connect=1; GetDlgItem(IDC_EDIT_BTR)->EnableWindow(!m_connect);//不激活"自定义波特率寄存器"编辑框 GetDlgItem(IDC_EDIT_STARTID)->EnableWindow(!m_connect);//不激活"滤波范围起始帧ID"编辑框 GetDlgItem(IDC_EDIT_ENDID)->EnableWindow(!m_connect);//不激活"滤波范围结束帧ID"编辑框 GetDlgItem(IDC_COMBO_BAUD)->EnableWindow(!m_connect);//不激活"波特率"组合框 GetDlgItem(IDC_COMBO_FILTER)->EnableWindow(!m_connect);//不激活"滤波模式"组合框 GetDlgItem(IDC_COMBO_MODE)->EnableWindow(!m_connect);//不激活"工作模式"组合框 GetDlgItem(IDC_BTN_STARTCAN)->SetWindowText("关闭CAN");//改变控件的文本内容 m_startcanlight.SetIcon(m_hIConGreen1); VCI_StartCAN(m_devtype,m_devind,m_cannum); AfxBeginThread(ReceiveThread,this);//启动线程，ReceiveThread为线程函数 //Sleep(8000); }UINT CCOMMUNICATIONSet::ReceiveThread(void *param)//接收CAN报文 线程函数的定义{ CCOMMUNICATIONSet *dlg=(CCOMMUNICATIONSet*)param; CListBox *box=(CListBox *)dlg->GetDlgItem(IDC_LIST_INFO); VCI_CAN_OBJ frameinfo[50];//定义CAN信息帧数据类型的结构体 VCI_ERR_INFO errinfo;//定义错误信息数据类型的结构体 int len=1; int i=0; CString str,tmpstr; while(1) { Sleep(1); if(dlg->m_connect==0)//未连接 break; len=VCI_Receive(dlg->m_devtype,dlg->m_devind,dlg->m_cannum,frameinfo,50,200);//从指定的设备读取数据 if(len<=0)//没有读到数据 { VCI_ReadErrInfo(dlg->m_devtype,dlg->m_devind,dlg->m_cannum,&errinfo);//获取最后一次错误信息 } else//读到数据 { for(i=0;i<len;i++) { str="接收到数据帧: ";if(frameinfo[i].TimeFlag==0)//无时间标识 tmpstr="时间标识:无 "; else tmpstr.Format("时间标识:%08x ",frameinfo[i].TimeStamp); str+=tmpstr;//接收到信息帧时的时间标识 tmpstr.Format("帧ID:%08x ",frameinfo[i].ID); str+=tmpstr;//报文IDstr+="帧格式:"; if(frameinfo[i].RemoteFlag==0) tmpstr="数据帧 "; else tmpstr="远程帧 "; str+=tmpstr;str+="帧类型:"; if(frameinfo[i].ExternFlag==0) tmpstr="标准帧 "; else tmpstr="扩展帧 "; str+=tmpstr;box->InsertString(box->GetCount(),str);//插入字符串if(frameinfo[i].RemoteFlag==0)//不是远程帧？ { str="数据:"; if(frameinfo[i].DataLen>8) frameinfo[i].DataLen=8; for(int j=0;j<frameinfo[i].DataLen;j++) { tmpstr.Format("%02x ",frameinfo[i].Data[j]); str+=tmpstr; } //EnterCriticalSection(&(dlg->m_Section));//获得指定的临界区对象的所有权 //LeaveCriticalSection(&(dlg->m_Section));//释放指定的临界区对象的所有权 box->InsertString(box->GetCount(),str); } CNaS_BMSDlg *m_Host = (CNaS_BMSDlg*)AfxGetMainWnd();//获取主界面的指针 if(frameinfo[7].Data[2]!=1) m_Host->xxx->m_page1.SendMessage(UM_ALARM,0,0); } box->SetCurSel(box->GetCount()-1);//box->GetCount():返回列表框中的字符串数目 } } return 0; }

程序里用线程锁CComSafeDeleteCriticalSection了吗，出错位置指向了CComSafeDeleteCriticalSection的Lock函数，出错原因好像是说在运行Lock前没有运行Init初始化函数。HRESULT Lock(){ // CComSafeDeleteCriticalSection::Init or CComAutoDeleteCriticalSection::Init // not called or failed. // m_critsec member of CComObjectRootEx is now of type // CComAutoDeleteCriticalSection. It has to be initialized // by calling CComObjectRootEx::_AtlInitialConstruct ATLASSUME(m_bInitialized); return CComCriticalSection::Lock();}

Windows32 Thread API共享数据互斥机制总共有四种：事件(Event)、临界区(Critical section)、互斥量(Mutex)、信号量(Semaphore)。现分别叙述如下：1、 事件(Event)：是WIN32提供的最灵活的线程间同步方式。使用方法：用CreateEvent创建一个事件。对于需要手工设置的事件，在需要该事件或者事件发生时，采用SetEvent及ResetEvent来进行设置。2、临界区(Critical section)：防止多个线程同时执行一个代码段。使用方法：1) 需要设置临界区时，要先定义临界区对象，采用CRITICAL_SECTION g_cs; 2) 使用前需初始化临界区，采用InitializeCriticalSection(&g_cs);函数3) 需要进入临界区时，采用：EnterCriticalSection(&g_cs);函数，从而阻止其他的线程进入。4) 离开临界区时，采用：LeaveCriticalSection(&g_cs);，从而让其他的线程可以进入该临界区。5) 当该临界区不再有使用价值时，需销毁临界区，采用：DeleteCriticalSection(&g_cs);3、互斥量(Mutex)：互斥量通常用于协调多个线程或进程的活动，控制对资源的“锁定”和“取消锁定”，从而控制对共享资源的访问。使用方法：1) 首先，建立互斥体对象，得到句柄使用HANDLE CreateMutex()函数；2) 然后，在线程可能产生冲突的区域前调用WaitForSingleObject函数，将句柄传给函数，请求占用互斥对象：dwWaitResult = WaitForSingleObject(hMutex,5000L)； 3) 共享资源访问结束，释放对互斥体对象的占用：ReleaseMutex(hMutex)； 4) 最后使用CloseHandle函数删除互斥体对象。4、信号量(Semaphore)：信号对象允许多个有限个数的线程同时访问共享资源。 使用方法：1) 当需要信号量时要先调用CreateSemaphore函数创建信号量2) 在需要请求资源时，调用WaitForSingleObject函数或者WaitForMultipleObject函数等待信号量。3) 资源使用完毕后，调用ReleaseSemaphore函数释放信号量

进程中线程同步的四种常用方式：1、 临界区（CCriticalSection）当多个线程访问一个独占性共享资源时，可以使用临界区对象。拥有临界区的线程可以访问被保护起来的资源或代码段，其他线程若想访问，则被挂起，直到拥有临界区的线程放弃临界区为止。请点击输入图片描述具体应用方式：1、 定义临界区对象CcriticalSection g_CriticalSection;2、 在访问共享资源（代码或变量）之前，先获得临界区对象，g_CriticalSection.Lock（）。请点击输入图片描述3、 访问共享资源后，则放弃临界区对象，g_CriticalSection.Unlock（）； 2、 事件（CEvent）事件机制，则允许一个线程在处理完一个任务后，主动唤醒另外一个线程执行任务。比如在某些网络应用程序中，一个线程如A负责侦听通信端口，另外一个线程B负责更新用户数据，利用事件机制，则线程A可以通知线程B何时更新用户数据。请点击输入图片描述每个Cevent对象可以有两种状态：有信号状态和无信号状态。Cevent类对象有两种类型：人工事件和自动事件。自动事件对象，在被至少一个线程释放后自动返回到无信号状态。请点击输入图片描述人工事件对象，获得信号后，释放可利用线程，但直到调用成员函数ReSet()才将其设置为无信号状态。请点击输入图片描述

Constructor HQDBHandle.Create(tHQDBStrList:TStringList); //重新定义你的构造函数要重载begin Lock := TCriticalSection.Create; HQDBStrList := TStringList.Create; HQDBStrList := tHQDBStrList; FreeOnTerminate := true; inherited Create(False); //把构造函数放在第一个end;

参考 　　—— 韩寒,《通稿2003》,《招生的问题》

同时按下ALT+CTRL+DELETE三个键即可知道当时系统和软件所用的资源各是多少，在里面都可以知道的