Help needed with simple multi-threading example - reply to this message

[Mark Huebner]

My reply e-mail address was wrong in the prior message. Sorry about that.

The following sample code for the lock statement is on page 112 of the
O'Reilly book "C# Essentials". Can somebody explain to me why this
recursive class definition of LockTest does not cause an infinite number of
LockTest objects to be created (i.e., until it consumes all available
memory)? I don't understand why only two threads are created.
using System;
using System.Threading;

class LockTest
{
static void Main()
{
LockTest lt = new LockTest();
Thread t = new Thread(new ThreadStart(lt.Go));
t.Start();
lt.Go();
}
void Go()
{
lock(this)
for (char c='a'; c<='z'; c++)
Console.Write(c);
}
}

[Richard A. Lowe]

Mark, all the 'Main' method does is run the instance method 'Go' on an
instance of the LockTest class twice, once through a the thread and once but
simply invoking the method. Go never calls itself it just locks using the
LockTest instance ('this') as the synchronication object and writes the
characters from a-z.

In order the app does this:
Create a new LockTest instance
Create a new threadstart delegate, passing the Go method as the target
Create a new thread
Start the Thread (thus invoking the Go method)
Invoke the Go method normally

Once both Go runs are finished, the program will exit.
HTH,
Richard

"Mark Huebner" <ne***@IntelligentSoftwareSystems.com> wrote in message
news:u7**************@TK2MSFTNGP11.phx.gbl...

My reply e-mail address was wrong in the prior message. Sorry about that.

The following sample code for the lock statement is on page 112 of the
O'Reilly book "C# Essentials". Can somebody explain to me why this
recursive class definition of LockTest does not cause an infinite number of LockTest objects to be created (i.e., until it consumes all available
memory)? I don't understand why only two threads are created.
using System;
using System.Threading;

class LockTest
{
static void Main()
{
LockTest lt = new LockTest();
Thread t = new Thread(new ThreadStart(lt.Go));
t.Start();
lt.Go();
}
void Go()
{
lock(this)
for (char c='a'; c<='z'; c++)
Console.Write(c);
}
}

[Mark Huebner]

But why doesn't the new LockTest instance create a new LockTest instance
which creates a new LockTest instance ... etc.? Why doesn't the compiler
consider this true recursion? I'm still not getting it.

"Richard A. Lowe" <ch*****@YUMSPAMYUMYahoo.com> wrote in message
news:OC**************@TK2MSFTNGP10.phx.gbl...

Mark, all the 'Main' method does is run the instance method 'Go' on an
instance of the LockTest class twice, once through a the thread and once but simply invoking the method. Go never calls itself it just locks using the
LockTest instance ('this') as the synchronication object and writes the
characters from a-z.

In order the app does this:
Create a new LockTest instance
Create a new threadstart delegate, passing the Go method as the target
Create a new thread
Start the Thread (thus invoking the Go method)
Invoke the Go method normally

Once both Go runs are finished, the program will exit.
HTH,
Richard

"Mark Huebner" <ne***@IntelligentSoftwareSystems.com> wrote in message
news:u7**************@TK2MSFTNGP11.phx.gbl...

My reply e-mail address was wrong in the prior message. Sorry about that.
The following sample code for the lock statement is on page 112 of the
O'Reilly book "C# Essentials". Can somebody explain to me why this
recursive class definition of LockTest does not cause an infinite number

of

LockTest objects to be created (i.e., until it consumes all available
memory)? I don't understand why only two threads are created.
using System;
using System.Threading;

class LockTest
{
static void Main()
{
LockTest lt = new LockTest();
Thread t = new Thread(new ThreadStart(lt.Go));
t.Start();
lt.Go();
}
void Go()
{
lock(this)
for (char c='a'; c<='z'; c++)
Console.Write(c);
}
}

[Simon Smith]

Main is a static method. Nothing in your code calls Main. The Runtime
calls Main when the exe is started. That's your first thread.
In Main, another LockTest is created. All that runs automatically is the
constructor. You then create a new thread and call Go on the new thread.
That's your second thread and that's it.
There is nothing special about the Main mathod. You can create a Main
method on as many classes as you want and it will never be called unless
you specifically call it (especially as it's static). The one thing different
about it is that it is the default entry point for when the exe is started,
that's all.
Simon Smith
simon dot s at ghytred dot com
www.ghytred.com/NewsLook - NNTP Client for Outlook

On 04 Jul 2004 07:30, "Mark Huebner" wrote:

But why doesn't the new LockTest instance create a new LockTest instance
which creates a new LockTest instance ... etc.? Why doesn't the compiler
consider this true recursion? I'm still not getting it.

"Richard A. Lowe" <ch*****@YUMSPAMYUMYahoo.com> wrote in message
news:OC**************@TK2MSFTNGP10.phx.gbl...

Mark, all the 'Main' method does is run the instance method 'Go' on an
instance of the LockTest class twice, once through a the thread and once

but

simply invoking the method. Go never calls itself it just locks using the
LockTest instance ('this') as the synchronication object and writes the
characters from a-z.

In order the app does this:
Create a new LockTest instance
Create a new threadstart delegate, passing the Go method as the target
Create a new thread
Start the Thread (thus invoking the Go method)
Invoke the Go method normally

Once both Go runs are finished, the program will exit.
HTH,
Richard

"Mark Huebner" <ne***@IntelligentSoftwareSystems.com> wrote in message
news:u7**************@TK2MSFTNGP11.phx.gbl...

> My reply e-mail address was wrong in the prior message. Sorry aboutthat. >
> The following sample code for the lock statement is on page 112 of the
> O'Reilly book "C# Essentials". Can somebody explain to me why this
> recursive class definition of LockTest does not cause an infinite number

of

> LockTest objects to be created (i.e., until it consumes all available
> memory)? I don't understand why only two threads are created.
>
>
> using System;
> using System.Threading;
>
> class LockTest
> {
> static void Main()
> {
> LockTest lt = new LockTest();
> Thread t = new Thread(new ThreadStart(lt.Go));
> t.Start();
> lt.Go();
> }
> void Go()
> {
> lock(this)
> for (char c='a'; c<='z'; c++)
> Console.Write(c);
> }
> }
>

[Richard A. Lowe]

Because the Main method is the only method where a LockTest instance is
created, and this method is only invoked once, by the runtime, as the entry
point to your application. Main isn't called every time a LockTest instance
is created.

Richard

"Mark Huebner" <ne***@IntelligentSoftwareSystems.com> wrote in message
news:%2****************@TK2MSFTNGP12.phx.gbl...

But why doesn't the new LockTest instance create a new LockTest instance
which creates a new LockTest instance ... etc.? Why doesn't the compiler
consider this true recursion? I'm still not getting it.

"Richard A. Lowe" <ch*****@YUMSPAMYUMYahoo.com> wrote in message
news:OC**************@TK2MSFTNGP10.phx.gbl...

Mark, all the 'Main' method does is run the instance method 'Go' on an
instance of the LockTest class twice, once through a the thread and once

but

simply invoking the method. Go never calls itself it just locks using the

LockTest instance ('this') as the synchronication object and writes the
characters from a-z.

In order the app does this:
Create a new LockTest instance
Create a new threadstart delegate, passing the Go method as the target
Create a new thread
Start the Thread (thus invoking the Go method)
Invoke the Go method normally

Once both Go runs are finished, the program will exit.
HTH,
Richard

"Mark Huebner" <ne***@IntelligentSoftwareSystems.com> wrote in message
news:u7**************@TK2MSFTNGP11.phx.gbl...

My reply e-mail address was wrong in the prior message. Sorry about that.
The following sample code for the lock statement is on page 112 of the
O'Reilly book "C# Essentials". Can somebody explain to me why this
recursive class definition of LockTest does not cause an infinite

number of

LockTest objects to be created (i.e., until it consumes all available
memory)? I don't understand why only two threads are created.
using System;
using System.Threading;

class LockTest
{
static void Main()
{
LockTest lt = new LockTest();
Thread t = new Thread(new ThreadStart(lt.Go));
t.Start();
lt.Go();
}
void Go()
{
lock(this)
for (char c='a'; c<='z'; c++)
Console.Write(c);
}
}