Archived:RMutex - Symbian mutex class

Article Metadata

---

Tested with

Devices(s): Nokia N95

---

Compatibility

Platform(s): S60 3rd Edition, MR

---

Platform Security

Capabilities: )

---

Article

Keywords: RMutex, RSemaphore, RThread

Created: tepaa (20 May 2008)

Last edited: debjit.roy (13 Mar 2012)

Archived: This article is archived because it is not considered relevant for third-party developers creating commercial solutions today. If you think this article is still relevant, let us know by adding the template {{ReviewForRemovalFromArchive|user=~~~~|write your reason here}}.

Overview

Using RMutex you can make sure that, for example, threads do not change the same value at the same time. RMutex.Wait() acquires a lock that opens with RMutex.Signal().

The following code is an update to the CS000867 - RThread example.

MMP file

The following capabilities and libraries are required:

CAPABILITY        NONE
LIBRARY           euser.lib

Header file

Shared data iSharedValue between threads.

class CShared : CBase
    {
    public:
        static CShared* NewL();
        virtual ~CShared();
 
    private:
        CShared();
 
    public:
        RMutex      iMutex;
        // Shared data
        TInt        iSharedValue;
    };

Source file

Create a thread and give the CShared data pointer in it.

// Create shared data
iSharedData = CShared::NewL();
 
// Create threads
iMyThread = CMyThread::NewL(*this);
iMyThread->SetShared(iSharedData);
 
iMyThread2 = CMyThread::NewL(*this);
iMyThread2->SetShared(iSharedData);

The thread fuction saysRMutex::Wait() and then sleeps.

TInt CMyThread::ThreadFunction(TAny* aParams)
    {
    // Add cleanup stack support.
    CTrapCleanup* cleanupStack = CTrapCleanup::New();
 
    // Get pointer to thread host
    CMyThread* host = (CMyThread*)aParams;
 
    TRAPD(err,
        // Add support for active objects
        CActiveScheduler* activeScheduler = new (ELeave) CActiveScheduler;
        CleanupStack::PushL(activeScheduler);
        CActiveScheduler::Install(activeScheduler);
 
        // Create and start CPeriodic class that is executed in this thread
        CPeriodic* periodic = CPeriodic::NewL(CActive::EPriorityLow);
        CleanupStack::PushL(periodic);
        periodic->Start(host->Interval(),host->Interval(),
        TCallBack(host->PeriodicTick, host));
 
        // NOTE: When adding CActiveScheduler support for threads we have to
        // add at least one active object in it or it fails on 
        // CActiveScheduler::Start().
        // CPeriodic is derived from CActive active object so that is good for
        // this example.
 
        // --> Thread execution starts
        CActiveScheduler::Start();
        // --> Thread execution ends (waiting for CActiveScheduler::Stop())
 
        CleanupStack::PopAndDestroy(periodic);
        CleanupStack::PopAndDestroy(activeScheduler);
        );
 
 
    host->ThreadExecuted(err);
    delete cleanupStack;
    return KErrNone;
    }

After sleeping the thread calls PeriodicTick() where it changes the shared data value and releases RMutex::Signal().

TInt CMyThread::PeriodicTick(TAny* aObject)
    {
    CMyThread* mythread = (CMyThread*)aObject;
    if (mythread)
        {
        // ---> Acquire the lock
        mythread->Shared()->iMutex.Wait();
 
        // Change shared data value
        mythread->Shared()->iSharedValue++;
 
        // ---> Release the lock
        mythread->Shared()->iMutex.Signal();
 
        // Thread is executed once so time to stop it
        CActiveScheduler::Stop();
 
        // After this execution continues from CActiveScheduler::Start()
        }
    // Does not continue again 
    // Note: Does not work with this CPeriodic class
    return EFalse; 
    }

CShared data implementation

CShared* CShared::NewL()
    {
    CShared* self = new (ELeave) CShared();
    return self;
    }
CShared::CShared()
    {
    iMutex.CreateLocal();
    }
CShared::~CShared()
    {
    iMutex.Close();
    }

Postconditions

Threads change shared data value in turns. The other thread waits if RMutex::Wait() is called and continues after RMutes::Signal().

See also

CS000867 - RThread Using RThread