Interprocess nonblocking semaphore / mutex / shared memory.

[m.p]

I rather write some os dependend code for mutex (CreateMutex() for Win and pthread for POSIX) than write segfaults handlers...

[wysota]

Create a protected resource that will determine if the resource you are after is available. Then regular lock() is fine because you only do the locking for a short moment.

class Sync {
public:
  Sync(const QString &key) : mem(key){
    dat = 0;
    if(mem.create(sizeof(bool))) dat = (bool*)mem.data();
    else return;
    mem.lock();
    *dat = true;
    mem.unlock();
  }
  ~Sync() { if(dat) mem.detach(); }
  bool tryLock() { 
    mem.lock(); 
    if(*dat) {
        /* lock the real resource here */; 
        *dat = false; 
        mem.unlock(); 
        return true;
    } else { mem.unlock(); return false; }
  }
  void lock() {
    mem.lock();
    if(*dat) { /* lock the resource, etc. */ } else {
      mem.unlock();
      // lock on a QSystemSemaphore
    }
  }
  // unlock in a similar fashion
private:
  QSharedMemory mem;
  bool *dat;
}

class Sync {
public:
  Sync(const QString &key) : mem(key){
    dat = 0;
    if(mem.create(sizeof(bool))) dat = (bool*)mem.data();
    else return;
    mem.lock();
    *dat = true;
    mem.unlock();
  }
  ~Sync() { if(dat) mem.detach(); }
  bool tryLock() { 
    mem.lock(); 
    if(*dat) {
        /* lock the real resource here */; 
        *dat = false; 
        mem.unlock(); 
        return true;
    } else { mem.unlock(); return false; }
  }
  void lock() {
    mem.lock();
    if(*dat) { /* lock the resource, etc. */ } else {
      mem.unlock();
      // lock on a QSystemSemaphore
    }
  }
  // unlock in a similar fashion
private:
  QSharedMemory mem;
  bool *dat;
}

To copy to clipboard, switch view to plain text mode 

This is ALMOST foul proof.

[m.p]

Create a protected resource that will determine if the resource you are after is available. Then regular lock() is fine because you only do the locking for a short moment.

bool tryLock() { 
    mem.lock(); 
[*]
 
    if(*dat) {
        /* lock the real resource here */; 
        *dat = false; 
        mem.unlock(); 
        return true;
    } else { mem.unlock(); return false; }
  }

bool tryLock() { 
    mem.lock(); 
[*]

    if(*dat) {
        /* lock the real resource here */; 
        *dat = false; 
        mem.unlock(); 
        return true;
    } else { mem.unlock(); return false; }
  }

To copy to clipboard, switch view to plain text mode 

This is ALMOST foul proof.

And what about when app will hang up in moment marked as[*]? Other app will also hangup becouse of blocking nature of lock()...

[wysota]

Why would it hang here?

[high_flyer]

I rather write some os dependend code for mutex (CreateMutex() for Win and pthread for POSIX) than write segfaults handlers...

The both are not related.
You raised a concern that one application may crash while it holds a resource.
You need to handle that case, no mater what type of locking mechanism you are using, be it deleting a file, or something else.
Google for "inter process communication", and choose the one best fits your needs.
There is nothing in Qt I know of for that, except may DBus but that is not supported on all platforms.