现在的位置: 首页 > 综合 > 正文

只允许运行一个实例的程序（互斥程序）

2018年04月05日 ⁄ 综合 ⁄ 共 8695字 ⁄ 字号 小 中 大 ⁄ 评论关闭
文章目录

有的时候我们需要编写出的应用程序在同一时间只允许运行一个实例，运行第二个实例时提示用户“该程序已经运行”。这是很老土的表示方法，但很灵验。
我找到了三种限制程序实例被多次运行的方法，它们有各自的优点，一会儿我会用一个控制台程序做例子，分别讨论这三种方法。有一种比较流行的方式，解决另人
恶心的“该程序已经运行”的对话框，比如千千静听，如果程序被第二次运行，它会直接将已经打开的程序前置，这样做确实温柔许多。我采用第二种方法来实现了
这个效果，就是第二个那个WinForm的例子。

准备工作

示例1


示例1的效果图

  1. /*
  2. * 标题：只允许运行一个实例的程序（互斥程序）示例
  3. * 原文：http://hi.baidu.com/wingingbob/blog/item/943f5f2396637846925807cf.html
  4. */
  6. #define METHOD1    //方法一
  7. //#define METHOD2    //方法二
  8. //#define METHOD3    //方法三
  10. using
    System;   
  11. using
    System.Text;   
  13. namespace
    ConsoleApplication1   
  14. {   
  15.     
    class
    Program   
  16.      {   
  17.         
    static

    void
    Main(
    string
    [] args)   
  18.          {   
  19.              Console.WriteLine(
    "==============="
    );   
  20.              Console.WriteLine(
    "互斥程序示例"
    );   
  21.              Console.WriteLine(
    "==============="
    );
  24. #if METHOD1      //方法一：同步基元
  25.             
    bool
    runone;   
  26.              System.Threading.Mutex run =
    new
    System.Threading.Mutex(
    true
    ,
    "只允许一个实例的程序_Bob"
    ,
    out
    runone);   
  27.             
    if
    (runone)   
  28.              {   
  29.                  run.ReleaseMutex();   
  30.                  MyMain();           
    //正常运行
  31.              }   
  32.             
    else
  33.              {   
  34.                  PrintWarnning();    
    //输出警告
  35.              }
  38. #elif METHOD2    //方法二：判断进程
  40.              System.Diagnostics.Process theProcess =
    null
    ;   
  41.              System.Diagnostics.Process current = System.Diagnostics.Process.GetCurrentProcess();    
    //当前进程
  42.              System.Diagnostics.Process[] processes = System.Diagnostics.Process.GetProcesses();     
    //所有进程
  43.              var myFilename = System.Reflection.Assembly.GetExecutingAssembly().Location.Replace(
    "/"
    , @
    "/"); //得到当前进程名"
  44.             
    foreach
    (var process
    in
    processes)   
  45.              {   
  46.                 
    //查找与当前进程相同名称的进程
  47.                 
    if
    (process.Id != current.Id && process.ProcessName == current.ProcessName)   
  48.                  {   
  49.                     
    //确认相同名称进程的程序运行位置是否一样
  50.                     
    try
  51.                      {   
  52.                         
    if
    (myFilename == process.MainModule.FileName)   
  53.                          {   
  54.                              theProcess = process;    
    //找到了此程序的另一个进程
  55.                          }   
  56.                      }   
  57.                     
    catch
    { }   
  58.                  }   
  59.              }   
  61.             
    if
    (theProcess ==
    null
    )   
  62.              {   
  63.                  MyMain();           
    //正常运行
  64.              }   
  65.             
    else
  66.              {   
  67.                  PrintWarnning();    
    //输出警告
  68.              }
  70. #elif METHOD3    //方法三：全局原子法
  71.             
    if
    (NativeMethods.GlobalFindAtomW(
    "只允许一个实例的程序_Bob"
    ) == 0)
    //没找到原子"只允许一个实例的程序"
  72.              {   
  73.                  var Atom = NativeMethods.GlobalAddAtomW(
    "只允许一个实例的程序_Bob"
    );  
    //添加原子"只允许一个实例的程序"
  74.                  MyMain();           
    //正常运行
  75.                  NativeMethods.GlobalDeleteAtom(Atom);   
    //一定记得程序退出时删除你的全局原子，否则只有在关机时它才会被清除。
  76.              }   
  77.             
    else
  78.              {   
  79.                 
    //NativeMethods.GlobalDeleteAtom(NativeMethods.GlobalFindAtomW("只允许一个实例的程序_Bob"));
  80.                  PrintWarnning();    
    //输出警告
  81.              }
  83. #endif
  84.          }   
  86.         
    /// <summary>
  87.         
    /// 输出警告
  88.         
    /// </summary>
  89.         
    private

    static

    void
    PrintWarnning()   
  90.          {   
  91.              Console.ForegroundColor = ConsoleColor.Red;   
  92.              Console.WriteLine(
    "警告：已经运行了一个实例了。"
    );   
  93.              Console.ReadLine();   
  94.          }   
  96.         
    /// <summary>
  97.         
    /// 正常运行
  98.         
    /// </summary>
  99.         
    private

    static

    void
    MyMain()   
  100.          {   
  101.              Console.WriteLine(
    "正常运行..."
    );   
  102.              Console.ReadLine();   
  103.          }
  107. #if METHOD3      //方法三：全局原子法
  108.          #region 查找原子
  110.         
    public
    partial
    class
    NativeMethods   
  111.          {   
  113.             
    /// Return Type: ATOM->WORD->unsigned short
  114.             
    ///lpString: LPCWSTR->WCHAR*
  115.              [System.Runtime.InteropServices.DllImportAttribute(
    "kernel32.dll"
    , EntryPoint =
    "GlobalFindAtomW"
    )]   
  116.             
    public

    static

    extern

    ushort

    GlobalFindAtomW([System.Runtime.InteropServices.InAttribute()]
    [System.Runtime.InteropServices.MarshalAsAttribute(System.Runtime.InteropServices.UnmanagedType.LPWStr)]

    string
    lpString);   
  119.             
    /// Return Type: ATOM->WORD->unsigned short
  120.             
    ///lpString: LPCSTR->CHAR*
  121.              [System.Runtime.InteropServices.DllImportAttribute(
    "kernel32.dll"
    , EntryPoint =
    "GlobalFindAtomA"
    )]   
  122.             
    public

    static

    extern

    ushort

    GlobalFindAtomA([System.Runtime.InteropServices.InAttribute()]
    [System.Runtime.InteropServices.MarshalAsAttribute(System.Runtime.InteropServices.UnmanagedType.LPStr)]

    string
    lpString);   
  124.          }
  125.          #endregion
  127.          #region 添加原子
  129.         
    public
    partial
    class
    NativeMethods   
  130.          {   
  132.             
    /// Return Type: ATOM->WORD->unsigned short
  133.             
    ///lpString: LPCWSTR->WCHAR*
  134.              [System.Runtime.InteropServices.DllImportAttribute(
    "kernel32.dll"
    , EntryPoint =
    "GlobalAddAtomW"
    )]   
  135.             
    public

    static

    extern

    ushort

    GlobalAddAtomW([System.Runtime.InteropServices.InAttribute()]
    [System.Runtime.InteropServices.MarshalAsAttribute(System.Runtime.InteropServices.UnmanagedType.LPWStr)]

    string
    lpString);   
  138.             
    /// Return Type: ATOM->WORD->unsigned short
  139.             
    ///lpString: LPCSTR->CHAR*
  140.              [System.Runtime.InteropServices.DllImportAttribute(
    "kernel32.dll"
    , EntryPoint =
    "GlobalAddAtomA"
    )]   
  141.             
    public

    static

    extern

    ushort

    GlobalAddAtomA([System.Runtime.InteropServices.InAttribute()]
    [System.Runtime.InteropServices.MarshalAsAttribute(System.Runtime.InteropServices.UnmanagedType.LPStr)]

    string
    lpString);   
  143.          }
  144.          #endregion
  146.          #region 删除原子
  147.         
    public
    partial
    class
    NativeMethods   
  148.          {   
  150.             
    /// Return Type: ATOM->WORD->unsigned short
  151.             
    ///nAtom: ATOM->WORD->unsigned short
  152.              [System.Runtime.InteropServices.DllImportAttribute(
    "kernel32.dll"
    , EntryPoint =
    "GlobalDeleteAtom"
    )]   
  153.             
    public

    static

    extern

    ushort
    GlobalDeleteAtom(
    ushort
    nAtom);   
  155.          }
  156.          #endregion
  158. #endif
  160.      }   
  161. }  

调试说明

看到6、7、8三行的预编译指令了吗？你可以通过注释、取消注释这三行来测试三种不同的方法。这段代码是完整的控制台程序源码，你可以使用csc命令来直接编译。每次将编译出来的程序同时打开数个，看输入结果。

方法一：同步基元

我认为最简单有效的方法。同步基元Mutex在MSDN中的解释是：“当两个或更多线程需要同时访问一个共
享资源时，系统需要使用同步机制来确保一次只有一个线程使用该资源。Mutex
是同步基元，它只向一个线程授予对共享资源的独占访问权。如果一个线程获取了互斥体，则要获取该互斥体的第二个线程将被挂起，直到第一个线程释放该互斥
体。”源程序第26行，当指定的命名系统互斥体已存在时，第三个参数会返回false，代码就会执行到第34条，输出“已经运行了一个实例了”的提示。具
体的方法请参见Mutex的构造函数
。

方法二：判断进程

进程判断是一个不错的方式，因为当你得到了这个进程，就可以对此进程进行一些操作，比如示例2的那种将已运行程序窗口置前的效果。但它最大的不足是，虽然
可以通过进程名（不同程序的进程名也可以相同的）和主程序集中存储的执行文件名信息来做判断，但是如果我的程序是多线程的（比如Chrome浏览器），便
无法正确处理下去。这种情况更适合使用方法一。在测试此方法的时候，需要说明一点的，第43行，得到当前进程名。如果你是在VS环境下调试，那么第一次得
到的进程文件名会是VS宿主的程序文件名，也就是“只允许一个实例的程
序.vshost.exe”。而它并不是我们期待得到的程序文件名“只允许一个实例的程序.exe”。此时再启动新实例，该行代码才会获得“只允
许一个实例的程序.exe”文件名。所以你需要启动第三个调试程序才会在52行判断成功。这并不是代码缺陷，特此说明。您可以直接运行bin目录中生成的
程序进行测试，没有问题的。

方法三：全局原子法

算是非常古老的方法，就是利用Windows给我们提供的全局原子来进行判断。我们在程序启动时，先判断
自己定义的一个全局原子（少于255字符）是否已经存在Windows系统中，如果不存在，当然程序就是第一次运行，注册自己定义的全局原子，正常加载程
序；否则就认为程序已经运行了，输出“已经运行了一个实例了”的提示。重要的是，主程序在退出时一定记得将我们定义的全局原子删除，否则只有在
Windows系统关机时，该全局原子才会被释放。这样一来，如果我们编写的程序被意外中止（比如程序本身的缺陷导致，软件冲突，或者被强制结束进程），
全局原子没被正确释放，那就只好等着机器重启了。因此我不推荐此方法。
此方法使用了三个Windows API函数：查找原子（GlobalFindAtom）、添加原子（GlobalAddAtom）和删除原子（GlobalDeleteAtom），你可以使用P/Invoke工具自己查找，然后帖到代码里。

 

示例2


示例2的效果图

  1. using
    System;   
  2. using
    System.Windows.Forms;   
  4. namespace
    WindowsFormsApplication1   
  5. {   
  6.     
    static

    class
    Program   
  7.      {   
  8.         
    /// <summary>
  9.         
    /// 应用程序的主入口点。
  10.         
    /// </summary>
  11.          [STAThread]   
  12.         
    static

    void
    Main()   
  13.          {   
  14.              var theProcess = GetRunningProcess();   
    //得到已经运行的进程
  15.             
    if
    (theProcess !=
    null
    )   
  16.              {   
  17.                 
    //应该程序已经运行，将其主窗口置前
  18.                  NativeMethods.ShowWindowAsync(theProcess.MainWindowHandle, 1);   
  19.                  NativeMethods.SetForegroundWindow(theProcess.MainWindowHandle);   
  20.              }   
  21.             
    else
  22.              {   
  23.                 
    //正常运行程序
  24.                  Application.EnableVisualStyles();   
  25.                  Application.SetCompatibleTextRenderingDefault(
    false
    );   
  26.                  Application.Run(
    new
    Form1());   
  27.              }   
  28.          }   
  30.         
    /// <summary>
  31.         
    /// 得到已经运行的进程
  32.         
    /// </summary>
  33.         
    /// <returns></returns>
  34.         
    static
    System.Diagnostics.Process GetRunningProcess()   
  35.          {   
  36.              System.Diagnostics.Process theProcess =
    null
    ;   
  37.              System.Diagnostics.Process current = System.Diagnostics.Process.GetCurrentProcess();    
    //当前进程
  38.              System.Diagnostics.Process[] processes = System.Diagnostics.Process.GetProcesses();     
    //所有进程
  39.              var myFilename = System.Reflection.Assembly.GetExecutingAssembly().Location.Replace(
    "/"
    , @
    "/"); //得到当前进程名"
  40.             
    foreach
    (var process
    in
    processes)   
  41.              {   
  42.                 
    //查找与当前进程相同名称的进程
  43.                 
    if
    (process.Id != current.Id && process.ProcessName == current.ProcessName)   
  44.                  {   
  45.                     
    //确认相同名称进程的程序运行位置是否一样
  46.                     
    try
  47.                      {   
  48.                         
    if
    (myFilename == process.MainModule.FileName)   
  49.                          {   
  50.                              theProcess = process;    
    //找到了此程序的另一个进程
  51.                          }   
  52.                      }   
  53.                     
    catch
    { }   
  54.                  }   
  55.              }   
  57.             
    return
    theProcess;   
  58.          }   
  60.         
    /*PInvoke 代码(见源程序)*/
  61.      }   
  62. }  
返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞