(转)防止程序启动两次的方法

方法一

 

在工程文件中, WinMain函数里加上以下代码(此代码在BCB6.0下运行):

HANDLE hMutex = CreateMutex(NULL, false, "Process");
         if (GetLastError() == ERROR_ALREADY_EXISTS)
         {
            CloseHandle(hMutex);
            MessageBox(Application->Handle, "程序已经在运行中，不能重复启动！", "提示", MB_OK +MB_ICONWARNING);
            Application->Terminate();
            return 0;
         }
         Application->CreateForm(__classid(TForm1), &Form1);

主要使用到CreateMutex()函数和GetLastError()以及一个常量ERROR_ALREADY_EXISTS.

方法二

当然, 你的程序有窗体的话, 还可以使用FindWindow().

void *handle = FindWindow(NULL, WindowName.c_str()); 
if (handle!=NULL)
    return 0; 

进程的互斥运行

 

（其他文章的一条评论）“FindWindow是最好的，其他互斥量在释放失败的时候会使程序再也打不开（直到注销或重启系统）
一般程序都是应用软件，如果是多个用户，你凭什么不让第二个用户运行？”

 

　　正常情况下，一个进程的运行一般是不会影响到其他正在运行的进程的。但是对于某些有特殊要求的如以独占方式使用串行口等硬件设备的程序就要求在其进程运行期间不允许其他试图使用此端口设备的程序运行的，而且此类程序通常也不允许运行同一个程序的多个实例。这就引出了进程互斥的问题。

　　实现进程互斥的核心思想比较简单：进程在启动时首先检查当前系统是否已经存在有此进程的实例，如果没有，进程将成功创建并设置标识实例已经存在的标记。此后再创建进程时将会通过该标记而知晓其实例已经存在，从而保证进程在系统中只能存在一个实例。具体可以采取内存映射文件、有名事件量、有名互斥量以及全局共享变量等多种方法来实现。下面就分别对其中具有代表性的有名互斥量和全局共享变量这两种方法进行介绍：

// 创建互斥量
HANDLE m_hMutex = CreateMutex(NULL, FALSE, "Sample07");
// 检查错误代码
if (GetLastError() == ERROR_ALREADY_EXISTS) {
　// 如果已有互斥量存在则释放句柄并复位互斥量
　CloseHandle(m_hMutex);
　m_hMutex = NULL;
　// 程序退出
　return FALSE;
}

上面这段代码演示了有名互斥量在进程互斥中的用法。代码的核心是CreateMutex（）对有名互斥量的创建。CreateMutex（）函数可用来创建一个有名或无名的互斥量对象，其函数原型为：

HANDLE CreateMutex(
　LPSECURITY_ATTRIBUTES lpMutexAttributes, // 指向安全属性的指针
　BOOL bInitialOwner, // 初始化互斥对象的所有者
　LPCTSTR lpName // 指向互斥对象名的指针
);

如果函数成功执行，将返回一个互斥量对象的句柄。如果在CreateMutex（）执行前已经存在有相同名字的互斥量，函数将返回这个已经存在互斥量的句柄，并且可以通过GetLastError（）得到错误代码ERROR_ALREADY_EXIST。可见，通过对错误代码ERROR_ALREADY_EXIST的检测可以实现CreateMutex（）对进程的互斥。

        建立互斥体，用来同步。如果一个线程获取了互斥体，则要获取该互斥体的第二个线程将被挂起，直到第一个线程释放该互斥体。

参数
lpMutexAttributes
指向一个SECURITY_ATTRIBUTES结构的指针，这个结构决定互斥体句柄是否被子进程继承。    
bInitialOwner
布尔类型，决定互斥体的创建者是否为拥有者
lpName
指向互斥体名字字符串的指针。互斥体可以有名字。
互斥体的好处是可以在进程间共享

心得体会：
    CreateMutex() 用于有独占要求的程序 (在其进程运行期间不允许其他使用此端口设备的程序运行，或不允许同名程序运行)。如有同名程序运行，则通过 GetLastError（）得到错误代码 ERROR_ALREADY_EXIST。

刚才又执行了下得出的结果（程序名samp）
       一般情况下：一进入调试阶段，进程管理器中就出现了samp进程，执行到CreateMutex时返回进程句柄，执行到if(GetLastError() == ERROR_ALREADY_EXISTS ) 进行判断时，跳过不执行if中的内容，所以表示没有互斥。
       调试之前先运行debug中的samp.exe再调试：一进入调试阶段，进程管理器中就出现了两个samp进程，执行到CreateMutex时返回进程句柄，执行到if(GetLastError() == ERROR_ALREADY_EXISTS ) 进行判断时，执行if中的内容，表示有互斥。

 

方法三：

建议使用原子。

C/C++ code

BOOL CMyDlg::OnInitDialog(){    CDialog::OnInitDialog();    ATOM atomCX = 0;    atomCX = GlobalFindAtom("YOUR ATOM");//查找原子    if (atomCX)    {        if (MessageBox("程序重复启动，是否终止前次启动的程序？","提问：",MB_ICONQUESTION|MB_YESNO) == IDYES)        {//关闭前次程序进程            GlobalDeleteAtom(atomCX);            HANDLE m_hfindhandle=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);            DWORD dCurrentId = GetCurrentProcessId();            PROCESSENTRY32* info=new PROCESSENTRY32;            info->dwSize=sizeof(PROCESSENTRY32);            if(Process32First(m_hfindhandle,info))             {                CString m_strname;//进程的名称                while(Process32Next(m_hfindhandle,info)!=FALSE)                {                    m_strname=info->szExeFile;                    m_strname.MakeUpper();                    if (m_strname == "YOUREXE.EXE")                    {                        if (dCurrentId != info->th32ProcessID)                        {                            HANDLE h=OpenProcess(PROCESS_ALL_ACCESS,TRUE,info->th32ProcessID);                                                        if(h!=NULL)                            {                                Sleep(100);                                TerminateProcess(h,0);                            }                        }                    }                }                CloseHandle(m_hfindhandle);//关闭进程否则会出现错误                if (info)                 {                    delete info;                }            }        }         else        {            CDialog::OnCancel();            return TRUE;        }    }    atomCX = GlobalAddAtom("YOUR ATOM");//注册本次程序原子return TRUE; }

另贴（未整理）

方法1：
在InitInstance里面 加上 
HWND oldHWnd = NULL; 
EnumWindows(EnumWndProc, (LPARAM)&oldHWnd); 
if(oldHWnd != NULL) 
{ 
::ShowWindow(oldHWnd, SW_SHOWMAXIMIZED); 
::SetForegroundWindow(oldHWnd); 
return FALSE; 
}
 
这个也是比较简单的 
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝方法的分割线＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
方法2：
有很多种方法。例如： 
使应用程序只能运行一个实例 

Windows是多进程操作系统，框架生成的应用程序可以多次运行，形成多个运行实例。 
但在有些情况下为保证应用程序的安全运行，要求程序只能运行一个实例，比如程 
序要使用只能被一个进程单独使用的特殊硬件（例如调制解调器）时，必须限制程 
序只运行一个实例。 

这里涉及两个基本的问题，一是在程序的第二个实例启动时，如何发现该程序已有 
一个实例在运行，而是如何将第一个实例激活，而第二个实例退出。 

对于第一个问题，可以通过给应用程序设置信号量，实例启动时首先检测该信号量， 
如已存在，则说明程序已运行一个实例。 

第二个问题的难点是获取第一个实例的主窗对象指针或句柄，然后便可用 
SetForegroundWindow来激活。虽然FindWindow函数能寻找正运行着的窗口，但该函 
数要求指明所寻找窗口的标题或窗口类名，不是实现通用方法的途径。 
我们可以用Win32 SDK函数SetProp来给应用程序主窗设置一个特有的标记。 
用GetDesktopWindow 可以获取Windows系统主控窗口对象指针或句柄，所有应用程 
序主窗都可看成该窗口的子窗口，即可用GetWindow函数来获得它们的对象指针或句 
柄。用Win32 SDK函数GetProp查找每一应用程序主窗是否包含有我们设置的特定标 
记便可确定它是否我们要寻找的第一个实例主窗。使第二个实例退出很简单，只要 
让其应用程序对象的InitInstance函数返回FALSE即可。此外，当主窗口退出时，应 
用RemoveProp函数删除我们为其设置的标记。 

下面的InitInstance、OnCreate和OnDestroy函数代码将实现上述的操作： 

BOOL CEllipseWndApp::InitInstance() 
{ 
// 用应用程序名创建信号量 
HANDLE hSem = CreateSemaphore(NULL, 1, 1, m_pszExeName); 

// 信号量已存在？ 
// 信号量存在，则程序已有一个实例运行 
if (GetLastError() == ERROR_ALREADY_EXISTS) 
{ 
// 关闭信号量句柄 
CloseHandle(hSem); 
// 寻找先前实例的主窗口 
HWND hWndPrevious = ::GetWindow(::GetDesktopWindow(),GW_CHILD); 
while (::IsWindow(hWndPrevious)) 
{ 
// 检查窗口是否有预设的标记? 
// 有，则是我们寻找的主窗 
if (::GetProp(hWndPrevious, m_pszExeName)) 
{ 
// 主窗口已最小化，则恢复其大小 
if (::IsIconic(hWndPrevious)) 
::ShowWindow(hWndPrevious,SW_RESTORE); 

// 将主窗激活 
::SetForegroundWindow(hWndPrevious); 

// 将主窗的对话框激活 
::SetForegroundWindow( 
::GetLastActivePopup(hWndPrevious)); 

// 退出本实例 
return FALSE; 
} 
// 继续寻找下一个窗口 
hWndPrevious = ::GetWindow(hWndPrevious,GW_HWNDNEXT); 
} 
// 前一实例已存在，但找不到其主窗 
// 可能出错了 
// 退出本实例 
return FALSE; 
} 
AfxEnableControlContainer(); 
// Standard initialization 
// If you are not using these features and wish to reduce the size 
// of your final executable, you should remove from the following 
// the specific initialization routines you do not need. 
#ifdef _AFXDLL 
Enable3dControls(); // Call this when using MFC in a shared DLL 
#else 
Enable3dControlsStatic();// Call this when linking to MFC statically 
#endif 

CEllipseWndDlg dlg; 
m_pMainWnd = &dlg; 
int nResponse = dlg.DoModal(); 
if (nResponse == IDOK) 
{ 
// TODO: Place code here to handle when the dialog is 
// dismissed with OK 
} 
else if (nResponse == IDCANCEL) 
{ 
// TODO: Place code here to handle when the dialog is 
// dismissed with Cancel 
} 
// Since the dialog has been closed, return FALSE so that we exit the 
// application, rather than start the application's message pump. 
return FALSE; 
} 

int CEllipseWndDlg::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{ 
if (CDialog::OnCreate(lpCreateStruct) == -1) 
return -1; 
// 设置寻找标记 
::SetProp(m_hWnd, AfxGetApp()->m_pszExeName, (HANDLE)1); 
return 0; 
} 

void CEllipseWndDlg::OnDestroy() 
{ 
CDialog::OnDestroy(); 
// 删除寻找标记 
::RemoveProp(m_hWnd, AfxGetApp()->m_pszExeName); 
} 


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

对以上代码的补充： 
查看代码和VC的帮助后，发现问题在于原文在创建信号量和设置寻找标记时使用 
的是 CWinApp 的成员变量 m_pszExeName，该成员变量其实是应用程序执行文件的名 
称去掉扩展名后的部分，而不是应用程序名。 

真正的应用程序名应为成员变量 m_pszAppName, 
于是将用到m_pszExeName的三处代码均改为m_pszAppName，重新编译执行，情况消失。 

最后再提供一个方法和一个信息： 

另一种使应用程序只能运行一个实例的方法，只需在InitInstance()的最开始添 
加下列语句即可： 
HANDLE m_hMutex=CreateMutex(NULL,TRUE, m_pszAppName); 
if(GetLastError()==ERROR_ALREADY_EXISTS) { return FALSE; } 

但这种方法的不足之处是不能将已经启动的实例激活。    
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝方法的分割线＝＝＝＝＝＝＝＝＝＝＝
方法3：
A． 使用编译器来实现（使用MFC框架）： 

在.cpp文件开头加上以下几行： #pragma data_seg("Shared") 
int volatile g_lAppInstance =0; 
#pragma data_seg() 

我们来看一下上面的内容： 
第一句 #pragma data_seg("Shared") 创建一个称为Shared 的新节。 
第二句 int volatile g_lAppInstance =0 将 g_lAppInstance 放入Shared节中。注意此时只有将g_lAppInstance初始化，编译器才会将其放入Shared节中，否则，将放入Shared以外的节。（实际上Visual C++ 编译器提供了一个allocate 说明符，使我们可以将数据放到任何节中。） 
第三句指示编译器Shared 节结束。 #pragma comment(linker,"/section:Shared,RWS") 

这一句，我们使编译链接器知道我们的Shared节具有读，写，共享的属性。这是我们实现互斥运行的关键。这样我们就可以在应用程序之间的多个实例之间共享g_lAppInstance 变量。 
在InitInstance() 函数中加入： if(++g_lAppInstance>1) 
{ 
AfxMessageBox("程序已经运行!"); 
return FALSE; 
} 
以上代码的作用是在程序是开始对g_lAppInstancd 加1 ，如果发现其值大于1，那么显示Message Box ,并返回FALSE。（注意：在MFC中如果InitInstance返回FALSE，程序将不会被运行！）  
 
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝还是分割线方法的＝＝＝＝＝＝＝＝＝＝＝＝＝＝
方法 4：
使用命名互斥对象： 

使用API函数CreateMutex来创建命名互斥对象来实现程序互斥是一个比较通用的方法，我们可以在IninInstance()函数加入如下代码: HANDLE hObject = CreateMutex(NULL,FALSE,"LJPXYXC"); 
if(GetLastError() == ERROR_ALREADY_EXISTS) 
{ 
CloseHandle(hObject); 
AfxMessageBox("程序已经运行!"); 
return FALSE; 
} 
以上的CreateMutext函数创建一个称为“LJPXYXC”的命名的互斥对象，当程序的第二个实例运例时，调用CreateMutex 返回ERROR_ALREADY_EXISTS。我们根据这个值来实现程序的互斥运行。   
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝还有其他的哦＝＝＝＝＝＝＝＝＝＝＝＝＝
方法其他 ：
OnCreate(LPCREATESTRUCT lpCreateStruct)里面 

m_hMutex=OpenMutex(MUTEX_ALL_ACCESS,FALSE,"自己取一个名字"); 
if(m_hMutex==NULL) 
CreateMutex(NULL,TRUE,"自己取一个名字"); 
else 
{ 
MessageBox("程序已经运行!"); 
return -1; 
} 
//在.h文件的类声明里面添加： 
HANDLE m_hMutex;
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝再其他＝＝＝＝＝＝＝＝＝＝＝＝
用命名的互斥! 
在你的程序启动是先判断一个互斥A有没有,如果互斥A不存在,就说明该程序没有启动,则启动该程序 
并创建该互斥A,在程序结束时销毁互斥A 

如果在启动程序时发向互斥A存在,怎说明程序已经启动了,则程序推出,并找到已经运行的程序的窗口,将它置在最前端!SetForegroundWindow
 
＝＝＝＝＝＝＝＝＝＝＝＝＝＝常用的其他＝＝＝＝＝＝＝＝＝＝＝
常用的方法
"m_hMutex=OpenMutex(MUTEX_ALL_ACCESS,FALSE,"自己取一个名字"); 
if(m_hMutex==NULL) 
CreateMutex(NULL,TRUE,"自己取一个名字"); 
else 
{ 
MessageBox("程序已经运行!"); 
return -1; 
} 
//在.h文件的类声明里面添加： 
HANDLE m_hMutex; 
"