×
Namespaces

Variants
Actions
(Difference between revisions)

Archived:RMutex - Symbian mutex class

From Nokia Developer Wiki
Jump to: navigation, search
extkbeditor1 (Talk | contribs)
m
lpvalente (Talk | contribs)
m (Lpvalente -)
 
(8 intermediate revisions by 3 users not shown)
Line 1: Line 1:
__NOTOC__
+
[[Category:Symbian C++]][[Category:Code Snippet]][[Category:S60 3rd Edition (initial release)]][[Category:Code Snippet]]
__NOEDITSECTION__
+
{{Archived|timestamp=20120313125720|user=roy.debjit| }}
{{KBCS}}
+
{{CodeSnippet
+
|id=CS000969
+
|platform=S60 3rd Edition, MR
+
|devices=Nokia N95
+
|category=Symbian C++
+
|subcategory=Code Examples
+
|creationdate=May 20, 2008
+
|keywords=RMutex, RSemaphore, RThread
+
}}
+
  
 +
{{ArticleMetaData <!-- v1.2 -->
 +
|sourcecode= <!-- Link to example source code (e.g. [[Media:The Code Example ZIP.zip]]) -->
 +
|installfile= <!-- Link to installation file (e.g. [[Media:The Installation File.sis]]) -->
 +
|devices= Nokia N95
 +
|sdk= <!-- SDK(s) built and tested against (e.g. [http://linktosdkdownload/ Nokia Qt SDK 1.1]) -->
 +
|platform= S60 3rd Edition, MR
 +
|devicecompatability= <!-- Compatible devices (e.g.: All* (must have GPS) ) -->
 +
|dependencies= <!-- Any other/external dependencies e.g.: Google Maps Api v1.0 -->
 +
|signing= <!-- Empty or one of Self-Signed, DevCert, Manufacturer -->
 +
|capabilities= <!-- Capabilities required by the article/code example (e.g. Location, NetworkServices. -->
 +
|keywords= RMutex, RSemaphore, RThread
 +
|language= <!-- Language category code for non-English topics - e.g. Lang-Chinese -->
 +
|translated-by= <!-- [[User:XXXX]] -->
 +
|translated-from-title= <!-- Title only -->
 +
|translated-from-id= <!-- Id of translated revision -->
 +
|review-by= <!-- After re-review: [[User:username]] -->
 +
|review-timestamp= <!-- After re-review: YYYYMMDD -->
 +
|update-by= <!-- After significant update: [[User:username]]-->
 +
|update-timestamp= <!-- After significant update: YYYYMMDD -->
 +
|creationdate= 20080513
 +
|author= [[User:Tepaa]]
 +
<!-- The following are not in current metadata -->
 +
|subcategory= Code Examples
 +
|id= CS000969
 +
}}
 +
 
 
==Overview==
 
==Overview==
Using  <tt>RMutex</tt> you can make sure that, for example, threads do not change the same value at the same time.
+
{{Abstract|Using  {{Icode|RMutex}} you can make sure that, for example, threads do not change the same value at the same time. {{Icode|RMutex.Wait()}} acquires a lock that opens with {{Icode|RMutex.Signal()}}.}}
<tt>RMutex.Wait()</tt> acquires a lock that opens with <tt>RMutex.Signal()</tt>.
+
  
The following code is an update to the [[CS000867 - RThread]] example.
+
The following code is an update to the [[Archived:RThread - Symbian threading example]] example.
  
 
==MMP file==
 
==MMP file==
 
The following capabilities and libraries are required:
 
The following capabilities and libraries are required:
 
<code cpp>
 
<code cpp>
CAPABILITY       NONE
+
CAPABILITY NONE
LIBRARY           euser.lib
+
LIBRARY euser.lib
 
</code>
 
</code>
  
 
==Header file==
 
==Header file==
Shared data <tt>iSharedValue</tt> between threads.
+
Shared data {{Icode|iSharedValue}} between threads.
 
<code cpp>
 
<code cpp>
 
class CShared : CBase
 
class CShared : CBase
Line 38: Line 53:
 
          
 
          
 
     public:
 
     public:
         RMutex     iMutex;
+
         RMutex iMutex;
 
         // Shared data
 
         // Shared data
         TInt       iSharedValue;
+
         TInt iSharedValue;
 
     };
 
     };
 
</code>
 
</code>
Line 46: Line 61:
  
 
==Source file==
 
==Source file==
Create a thread and give the <tt>CShared</tt> data pointer in it.
+
Create a thread and give the {{Icode|CShared}} data pointer in it.
 
<code cpp>
 
<code cpp>
 
// Create shared data
 
// Create shared data
Line 59: Line 74:
 
</code>
 
</code>
  
The thread fuction says<tt>RMutex::Wait()</tt> and then sleeps.
+
The thread fuction says{{Icode|RMutex::Wait()}} and then sleeps.
 
<code cpp>
 
<code cpp>
 
TInt CMyThread::ThreadFunction(TAny* aParams)
 
TInt CMyThread::ThreadFunction(TAny* aParams)
Line 102: Line 117:
 
</code>
 
</code>
  
After sleeping the thread calls <tt>PeriodicTick()</tt> where it changes the shared
+
After sleeping the thread calls {{Icode|PeriodicTick()}} where it changes the shared
data value and releases <tt>RMutex::Signal()</tt>.
+
data value and releases {{Icode|RMutex::Signal()}}.
 
<code cpp>
 
<code cpp>
 
TInt CMyThread::PeriodicTick(TAny* aObject)
 
TInt CMyThread::PeriodicTick(TAny* aObject)
Line 130: Line 145:
 
</code>
 
</code>
  
<tt>CShared</tt> data implementation
+
{{Icode|CShared}} data implementation
 
<code cpp>
 
<code cpp>
 
CShared* CShared::NewL()
 
CShared* CShared::NewL()
Line 152: Line 167:
  
 
==See also==
 
==See also==
[[CS000867 - RThread]] Using RThread
+
[[Archived:RThread - Symbian threading example]] Using RThread
 
+
[[Category:Symbian C++]][[Category:Code Examples]][[Category:S60 3rd Edition]]
+

Latest revision as of 00:10, 2 September 2012

Archived.pngArchived: 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}}.

Article Metadata
Tested with
Devices(s): Nokia N95
Compatibility
Platform(s): S60 3rd Edition, MR
S60 3rd Edition (initial release)
Article
Keywords: RMutex, RSemaphore, RThread
Created: tepaa (13 May 2008)
Last edited: lpvalente (02 Sep 2012)

Contents

[edit] 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 Archived:RThread - Symbian threading example example.

[edit] MMP file

The following capabilities and libraries are required:

CAPABILITY NONE
LIBRARY euser.lib

[edit] 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;
};


[edit] 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();
}


[edit] Postconditions

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

[edit] See also

Archived:RThread - Symbian threading example Using RThread

This page was last modified on 2 September 2012, at 00:10.
102 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.

×