CAPABILITY        NONE
LIBRARY           euser.lib

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

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

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;
    }

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* CShared::NewL()
    {
    CShared* self = new (ELeave) CShared();
    return self;
    }
CShared::CShared()
    {
    iMutex.CreateLocal();
    }
CShared::~CShared()
    {
    iMutex.Close();
    }