标签: mutex

为了只允许运行应用程序的单个实例,我正在使用互斥锁.代码如下.这是正确的方法吗？代码中是否有任何缺陷？

当用户第二次尝试打开应用程序时,如何显示已在运行的应用程序.目前(在下面的代码中),我只是显示另一个实例已在运行的消息.

    static void Main(string[] args)
    {
        Mutex _mut = null;

        try
        {
            _mut = Mutex.OpenExisting(AppDomain.CurrentDomain.FriendlyName);
        }
        catch
        {
             //handler to be written
        }

        if (_mut == null)
        {
            _mut = new Mutex(false, AppDomain.CurrentDomain.FriendlyName);
        }
        else
        {
            _mut.Close();
            MessageBox.Show("Instance already running");

        }            
    }

我发现了这个: 快速进程间同步方法

我曾经认为pthread互斥锁只能在同一地址空间中的两个线程之间共享.

那里的问题/答案似乎意味着:

如果我有两个单独的程序A和B.它们有一个共享的内存区域M.我可以将一个pThread互斥锁放在M中,锁定在A中,锁定在B中,在A中解锁; 和B将不再阻止互斥锁.它是否正确？可以在两个独立的进程中共享pThread互斥锁吗？

编辑:我在MacOSX上使用C++.

阅读一些关于在PHP中锁定的文章.
它们主要指向http://php.net/manual/en/function.flock.php.

这个页面讨论了在硬盘上打开文件!!

真的是这样吗？我的意思是,这使得锁定非常昂贵 - 这意味着每次我想要锁定我都必须访问硬盘)=

可以用一个令人愉快的消息来安慰我吗？

编辑:

由于我有一些回复,我想问这个;
我的脚本只能运行一个或几个线程？因为如果它是一个然后我显然不需要互斥量.有简明的答案吗？

究竟我想要做什么

由ircmaxell提问.
这是故事:

我有两个ftp服务器.我希望能够在我的网站上显示有多少在线用户在线.
所以,我认为这些ftp服务器会将他们的统计信息"POST"到某个PHP脚本页面.我们假设此页面的URL是" http://mydomain.com/update.php ".

在网站的主页(" http://mydomain.com/index.php ")上,我将显示累积统计信息(在线用户).

而已.

我的问题是,我不确定当一个ftp服务器更新他的统计数据而另一个ftp服务器也是如此时,信息会变得混杂.
就像多线程时一样; 两个线程同时增加一些"int"变量.除非您在它们之间进行同步,否则它不会按预期发生.
那么,我有问题吗？是的,不,也许吧？

可能解决方案

一整天都在努力思考,我在这里有一个想法,我想让你发表意见.
正如所说的这些ftp服务器将发布他们的统计数据,每60秒一次.
我正在考虑将此文件设为"stats.php".
它将包含在ftp服务器转到的更新脚本("update.php")和"index.php"页面中,访问者可以看到有多少用户在线.
现在,当ftp服务器更新时,"update.php"中的脚本将使用新的累积统计信息修改"stats.php".
首先,它将读取"stats.php"中包含的统计信息,然后累积,然后重写该文件.

如果我没弄错,PHP将检测到文件("stats.php")已更改并加载新文件.正确？

当我查看一些遗留应用程序代码时,我注意到它正在使用字符串对象来进行线程同步.我正在尝试解决此程序中的一些线程争用问题,并想知道这是否会导致如此奇怪的情况.有什么想法吗 ？

private static string mutex= "ABC";

internal static void Foo(Rpc rpc)
{
    lock (mutex)
    {
        //do something
    }
}

在一次采访中询问了这个问题.第一部分是编写单例类:

class Singleton
{
    static Singleton *singletonInstance;
    Singleton() {}

  public:
    static Singleton* getSingletonInstance()
    {
        if(singletonInstance == null)
        {
            singletonInstance = new Singleton();
        }
        return singletonInstance;
    }
};

然后我被问到如何getSingletonInstance()在多线程情况下处理这个问题.我不太确定,但我修改为:

class Singleton 
{
    static Singleton *singletonInstance;
    Singleton() {}
    static mutex m_;

  public:
    static Singleton* getSingletonInstance()
    {
        m_pend();
        if(singletonInstance == null)
        {
            singletonInstance = new Singleton();
        }
        return singletonInstance;
    }

    static void releaseSingleton()
    {
        m_post();
    }
};

然后有人告诉我,虽然需要一个互斥锁,但挂起和发布互斥锁效率不高,因为需要时间.并且有一种更好的方法来应对这种情况.

有没有人知道在多线程情况下处理单例类的更好,更有效的方法？

我正在用IPC进行实验,特别是使用Mutex,Semaphore和Spin Lock.我学到的是Mutex用于异步锁定(具有睡眠(根据我在NET上读到的理论))机制,信号量是同步锁定(具有信号和睡眠)机制,并且自旋锁是同步但非睡眠机制.

任何人都可以帮我澄清这些东西吗？另一个疑问是关于Mutex,当我用线程和互斥体编写程序时,一个线程正在运行另一个线程不处于Sleep状态但它不断尝试获取Lock.所以Mutex正在睡觉或不睡觉???

如何从C#中的互斥锁中找到获取互斥锁的？

如果mutex.WaitOne(timeout)超时,则返回false.但是,如何从互斥锁手柄中找到它？(也许使用p/invoke.)

更新:

public class InterProcessLock : IDisposable
{
    readonly Mutex mutex;

    public bool IsAcquired { get; private set; }

    public InterProcessLock(string name, TimeSpan timeout)
    {
        bool created;
        var security = new MutexSecurity();
        security.AddAccessRule(new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.Synchronize | MutexRights.Modify, AccessControlType.Allow));
        mutex = new Mutex(false, name, out created, security);
        IsAcquired = mutex.WaitOne(timeout);
    }

    #region IDisposable Members

    public void Dispose()
    {
        if (IsAcquired)
        {
            mutex.ReleaseMutex();
            IsAcquired = false;
        }
    }

    #endregion
}

目前,我正在使用自己的属性IsAcquired来确定是否应该释放互斥锁.不是必要但更清楚,不是使用IsAcquired …

互斥体背后的想法是只允许一个线程一次访问一段内存.如果一个线程锁定互斥锁,则任何其他锁定尝试将阻塞,直到第一个锁定尝试解锁.但是,这是如何实现的？为了锁定自己,互斥锁必须设置一个位置,表示它已被锁定.但是,如果第二个互斥锁在第一个写入的同时正在读取,那该怎么办呢？更糟糕的是,如果他们同时锁定互斥锁怎么办？互斥体会屈服于它要防止的同样问题.

互斥体如何真正起作用？

我可以生成一个线程pthread_create并std::mutex安全地使用它吗？

我认为如果std::mutex实现为a pthread_mutex_t那么它会很好,但我没有看到任何记录

例如:

#include <pthread.h>
#include <mutex>

namespace {
std::mutex global_lock;
}

void* thread_func(void* vp) {
    // std::mutex used in thread spawned with pthread_create
    std::lock_guard<std::mutex> guard(global_lock);
    // critical section
    return nullptr;
}

int main() {
    pthread_t tid;
    pthread_create(&tid, nullptr, thread_func, nullptr);
    pthread_join(tid, NULL);
}

顺便说一下,我正在运行Debian Wheezy.

如果我有一个我要从一个线程写入并从另一个线程读取的int,我需要使用std::atomic,以确保它的值在内核之间是一致的,无论是否读取和写入它的指令在概念上是原子的.如果不这样做,可能是读取内核的缓存中有旧值,并且不会看到新值.这对我来说很有意义.

如果我有一些无法以原子方式读/写的复杂数据类型,我需要使用一些同步原语来保护对它的访问,例如std::mutex.这将防止对象进入(或被读取)不一致的状态.这对我来说很有意义.

对我来说没有意义的是互斥体如何帮助解决原子解决的缓存问题.它们似乎只是为了防止对某些资源的并发访问,而不是将该资源中包含的任何值传播到其他核心的缓存.是否有一部分他的语义我错过了处理这个？