Archived:RMutex - Symbian mutex class
hamishwillee
(Talk | contribs) m (Hamishwillee - Bot change of template (Template:CodeSnippet) - now using Template:ArticleMetaData) |
debjit.roy
(Talk | contribs) (Debjit.roy -) |
||
| Line 1: | Line 1: | ||
| + | [[Category:Symbian C++]][[Category:Code Examples]][[Category:S60 3rd Edition]][[Category:Code Snippet]] | ||
__NOTOC__ | __NOTOC__ | ||
__NOEDITSECTION__ | __NOEDITSECTION__ | ||
| Line 19: | Line 20: | ||
|author=[[User:Tepaa]] | |author=[[User:Tepaa]] | ||
}} | }} | ||
| − | + | {{Archived|timestamp=20120313125720|user=roy.debjit| }} | |
| + | |||
==Overview== | ==Overview== | ||
Using <tt>RMutex</tt> you can make sure that, for example, threads do not change the same value at the same time. | Using <tt>RMutex</tt> you can make sure that, for example, threads do not change the same value at the same time. | ||
| Line 161: | Line 163: | ||
==See also== | ==See also== | ||
[[CS000867 - RThread]] Using RThread | [[CS000867 - RThread]] Using RThread | ||
| − | |||
| − | |||
Revision as of 15:57, 13 March 2012
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
