×
Namespaces

Variants
Actions
(Difference between revisions)

Archived:RMutex - Symbian mutex class

From Nokia Developer Wiki
Jump to: navigation, search
Forum Nokia KB (Talk | contribs)
Forum Nokia KB (Talk | contribs)
Line 1: Line 1:
 
__NOTOC__
 
__NOTOC__
 
__NOEDITSECTION__
 
__NOEDITSECTION__
 
+
{{KBCS}}
 
{|style="background:#eceff2" width="660px" border="1" cellpadding="5" cellspacing="0"  
 
{|style="background:#eceff2" width="660px" border="1" cellpadding="5" cellspacing="0"  
 
|-
 
|-
|'''ID''' ||
+
|'''ID''' ||CS000969
|'''Creation date''' || May 13, 2008
+
|'''Creation date''' || May 20, 2008
 
|-
 
|-
 
|'''Platform''' || S60 3rd Edition, MR
 
|'''Platform''' || S60 3rd Edition, MR
Line 22: Line 22:
  
 
==Overview==
 
==Overview==
Via <tt>RMutex</tt> you can be sure that e.g. threads do not change same
+
Using  <tt>RMutex</tt> you can make sure that, for example, threads do not change the same value at the same time.
value in the same time.
+
<tt>RMutex.Wait()</tt> acquires a lock that opens with <tt>RMutex.Signal()</tt>.
<tt>RMutex.Wait()</tt> acquire the lock that opens with <tt>RMutex.Signal()</tt>.
+
  
Following code is update into [[CS000867_-_RThread]] RThread example.
+
The following code is an update to the [[CS000867 - RThread]] example.
  
 
==MMP file==
 
==MMP file==
Line 56: Line 55:
  
 
==Source file==
 
==Source file==
Create thread and give <tt>CShared</tt> data pointer in it.
+
Create a thread and give the <tt>CShared</tt> data pointer in it.
 
<code cpp>
 
<code cpp>
 
// Create shared data
 
// Create shared data
Line 69: Line 68:
 
</code>
 
</code>
  
Thread fuction says<tt>RMutex::Wait()</tt> and then sleeps.
+
The thread fuction says<tt>RMutex::Wait()</tt> and then sleeps.
 
<code cpp>
 
<code cpp>
 
TInt CMyThread::ThreadFunction(TAny* aParams)
 
TInt CMyThread::ThreadFunction(TAny* aParams)
Line 112: Line 111:
 
</code>
 
</code>
  
After sleeping thread calls <tt>PeriodicTick()</tt> where it changes the shared
+
After sleeping the thread calls <tt>PeriodicTick()</tt> where it changes the shared
data value and release <tt>RMutex::Signal()</tt>
+
data value and releases <tt>RMutex::Signal()</tt>.
 
<code cpp>
 
<code cpp>
 
TInt CMyThread::PeriodicTick(TAny* aObject)
 
TInt CMyThread::PeriodicTick(TAny* aObject)
Line 159: Line 158:
  
 
==Postconditions==  
 
==Postconditions==  
Threads changes shared data value in turns. Another thread waits if RMutex::Wait() is called and continues after RMutes::Signal().
+
Threads change shared data value in turns. The other thread waits if RMutex::Wait() is called and continues after RMutes::Signal().
  
 
==See also==
 
==See also==
[[CS000867_-_RThread]] Using RThread
+
[[CS000867 - RThread]] Using RThread
  
[[Category:Symbian C++]][[Category:Code Examples]]
+
[[Category:Symbian C++]][[Category:Code Examples]][[Category:S60 3rd Edition]]

Revision as of 13:18, 20 May 2008


Template:KBCS

ID CS000969 Creation date May 20, 2008
Platform S60 3rd Edition, MR Tested on devices Nokia N95
Category Symbian C++ Subcategory Code Examples


Keywords (APIs, classes, methods, functions): RMutex, RSemaphore, RThread

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

101 page views in the last 30 days.

Was this page helpful?

Your feedback about this content is important. Let us know what you think.

 

Thank you!

We appreciate your feedback.

×