Interprocess nonblocking semaphore / mutex / shared memory.

[m.p]

I have been thinking about that solution, but what if one of process that acquired acces to resources and created temp file crashed before it can delete this temp file? Other proces will be thinking, that resources are loocked.

[high_flyer]

You can handle that by catching and handling SIGSEGV signal.
You can search in the forum there are several threads about it, or google it.

[m.p]

SIGSEGV is a POSIX signal. I need multiplatform solution.

[high_flyer]

Well, then you will just have to implement the segmentation fault catching per system, and guard it with #ifdef <your OS>.
Just few more lines of code.
But any OS should have some sort of signal on segmentation fault, either POSIX or something else.
OR -
On windows, you can for example use exceptions, and raise a SIGSEGV your self, and then you need only one signal handler for POSIX and Windows.
http://msdn.microsoft.com/en-us/libr...=vs.71%29.aspx

The SIGILL, SIGSEGV, and SIGTERM signals are not generated under Windows NT. They are included for ANSI compatibility. Thus you can set signal handlers for these signals with signal, and you can also explicitly generate these signals by calling raise.

[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.