What exactly does it mean when they say

[cj]

members of this type are safe for multithreaded operations. Instance
members are not guaranteed to be thread-safe.
I'm under the impression before you can use a class you have to make an
instance of it. So how can a class be threadsafe by itself but an
instance of it not be?

I guess I don't get what exactly being threadsafe means. Multiple
theads can use the same instance of a class?

[Marina Levit [MVP]]

Those classes may have shared methods. In which case, those methods are
thread safe. So if multiple threads are calling the same shared method,
that is safe and no extra precautions need to be taken by the developer.

If 2 threads are pointing to the same instance of the class, then those
instance methods are not guaranteed to be thread safe, and it is up to the
developer to synchronize access.

"cj" <[e-mail] amwrote in message
news:uN******** ******@TK2MSFTN GP02.phx.gbl...

members of this type are safe for multithreaded operations. Instance
members are not guaranteed to be thread-safe.
I'm under the impression before you can use a class you have to make an
instance of it. So how can a class be threadsafe by itself but an
instance of it not be?

I guess I don't get what exactly being threadsafe means. Multiple theads
can use the same instance of a class?

[cj]

Sorry but to me these two situations sound the same. I don't understand
what the difference is. To use a class I have to create an instance of
it, right? Then I have multiple threads that will want to call methods
in that instance of the class. Not thread safe? Or thread safe?

Marina Levit [MVP] wrote:

Those classes may have shared methods. In which case, those methods are
thread safe. So if multiple threads are calling the same shared method,
that is safe and no extra precautions need to be taken by the developer.

If 2 threads are pointing to the same instance of the class, then those
instance methods are not guaranteed to be thread safe, and it is up to the
developer to synchronize access.

"cj" <[e-mail] amwrote in message
news:uN******** ******@TK2MSFTN GP02.phx.gbl...

>members of this type are safe for multithreaded operations. Instance
members are not guaranteed to be thread-safe.
I'm under the impression before you can use a class you have to make an
instance of it. So how can a class be threadsafe by itself but an
instance of it not be?

I guess I don't get what exactly being threadsafe means. Multiple theads
can use the same instance of a class?

[Jared Parsons [MSFT]]

Hello cj,

Sorry but to me these two situations sound the same. I don't
understand what the difference is. To use a class I have to create an
instance of it, right? Then I have multiple threads that will want to
call methods in that instance of the class. Not thread safe? Or
thread safe?

That case is not thread safe. The case that is thread safe are when you
call the "shared" methods. These are not associated with an instance and
the documentation indicates they are safe for multi-threaded access.

--
Jared Parsons [MSFT]
ja******@online .microsoft.com
All opinions are my own. All content is provided "AS IS" with no warranties,
and confers no rights.

[Travers Naran]

cj wrote:

Sorry but to me these two situations sound the same. I don't understand
what the difference is. To use a class I have to create an instance of
it, right?

No.

There are two types of methods on classes. Instance methods and Shared
methods.

An instance method is declared:
Public Sub Foo()
....
End Sub

A shared method is declared:
Public Shared Sub Bar()
....
End Sub

If the class is called Foobar, then to call Foo:

dim o as new Foobar
o.Foo()

Notice I had to create an instance first. But to call Bar:

Foobar.Bar()

I don't have to create an instance because it is _shared_. I simply
use the name of the class. In C++-speak, it's a static method. In OOP
speak, a _class_ method.

Example in the framework:
Int32.Parse("42 ")

[Marina Levit [MVP]]

No, you do not always need an instance of a class to use it.

I think you need to read up on what shared methods are.

"cj" <[e-mail] amwrote in message
news:eP******** ********@TK2MSF TNGP04.phx.gbl. ..

Sorry but to me these two situations sound the same. I don't understand
what the difference is. To use a class I have to create an instance of
it, right? Then I have multiple threads that will want to call methods in
that instance of the class. Not thread safe? Or thread safe?

Marina Levit [MVP] wrote:

>Those classes may have shared methods. In which case, those methods are
thread safe. So if multiple threads are calling the same shared method,
that is safe and no extra precautions need to be taken by the developer.

If 2 threads are pointing to the same instance of the class, then those
instance methods are not guaranteed to be thread safe, and it is up to
the developer to synchronize access.

"cj" <[e-mail] amwrote in message
news:uN******* *******@TK2MSFT NGP02.phx.gbl.. .

>>members of this type are safe for multithreaded operations. Instance
members are not guaranteed to be thread-safe.
I'm under the impression before you can use a class you have to make an
instance of it. So how can a class be threadsafe by itself but an
instance of it not be?

I guess I don't get what exactly being threadsafe means. Multiple
theads can use the same instance of a class?

[cj]

Ok.

But the act of declaring Public Shared alone doesn't make it threadsafe
does it? I have this class MyThreadCount (see below) which creates
public shared classes but I was told I had to use the synclock to keep
multiple threads from manipulating the count at the same time. Is this
true?

Public Class MyThreadCount

Private Shared m_lock As New Object
Private Shared m_threadcount As Int32 = 0

Public Shared Sub Increment()
SyncLock (m_lock)
m_threadcount += 1
End SyncLock
End Sub

Public Shared Sub Decrement()
SyncLock (m_lock)
m_threadcount -= 1
End SyncLock
End Sub

Public Shared ReadOnly Property ThreadCount() As Int32
Get
Dim _count As Int32
SyncLock (m_lock)
_count = m_threadcount
End SyncLock
Return _count
End Get
End Property
End Class
Travers Naran wrote:

cj wrote:

>Sorry but to me these two situations sound the same. I don't understand
what the difference is. To use a class I have to create an instance of
it, right?

No.

There are two types of methods on classes. Instance methods and Shared
methods.

An instance method is declared:
Public Sub Foo()
...
End Sub

A shared method is declared:
Public Shared Sub Bar()
...
End Sub

If the class is called Foobar, then to call Foo:

dim o as new Foobar
o.Foo()

Notice I had to create an instance first. But to call Bar:

Foobar.Bar()

I don't have to create an instance because it is _shared_. I simply
use the name of the class. In C++-speak, it's a static method. In OOP
speak, a _class_ method.

Example in the framework:
Int32.Parse("42 ")

[Marina Levit [MVP]]

No, having a method declared as Shared does not automatically make it thread
safe.

But if there is a note in the documentation that says it is thread safe,
then developers of that method took precautions to make sure it is.

"cj" <[e-mail] amwrote in message
news:un******** ******@TK2MSFTN GP02.phx.gbl...

Ok.

But the act of declaring Public Shared alone doesn't make it threadsafe
does it? I have this class MyThreadCount (see below) which creates public
shared classes but I was told I had to use the synclock to keep multiple
threads from manipulating the count at the same time. Is this true?

Public Class MyThreadCount

Private Shared m_lock As New Object
Private Shared m_threadcount As Int32 = 0

Public Shared Sub Increment()
SyncLock (m_lock)
m_threadcount += 1
End SyncLock
End Sub

Public Shared Sub Decrement()
SyncLock (m_lock)
m_threadcount -= 1
End SyncLock
End Sub

Public Shared ReadOnly Property ThreadCount() As Int32
Get
Dim _count As Int32
SyncLock (m_lock)
_count = m_threadcount
End SyncLock
Return _count
End Get
End Property
End Class
Travers Naran wrote:

>cj wrote:

>>Sorry but to me these two situations sound the same. I don't understand
what the difference is. To use a class I have to create an instance of
it, right?

No.

There are two types of methods on classes. Instance methods and Shared
methods.

An instance method is declared:
Public Sub Foo()
...
End Sub

A shared method is declared:
Public Shared Sub Bar()
...
End Sub

If the class is called Foobar, then to call Foo:

dim o as new Foobar
o.Foo()

Notice I had to create an instance first. But to call Bar:

Foobar.Bar()

I don't have to create an instance because it is _shared_. I simply
use the name of the class. In C++-speak, it's a static method. In OOP
speak, a _class_ method.

Example in the framework:
Int32.Parse("4 2")

[cj]

Ok, believe it or not were making progress. I think between my
threadcount class and Travers examples I'm getting an idea of how to
write a class that's threadsafe or not.

But for MS classes... Right now I'm looking at the Queue class and it
says, "Public static (Shared in Visual Basic) members of this type are
safe for multithreaded operations." How do I tell which of the methods
listed under Queue Members are public static? They list Public
Constructor, Public Properties, Public Methods, and protected Methods.
I see the thread safe message a lot and I would like to know what
exactly it's saying is and isn't threadsafe about the class or how I use
it. If there is a better MS class example than the Queue class feel
free to point it out.
Marina Levit [MVP] wrote:

No, having a method declared as Shared does not automatically make it thread
safe.

But if there is a note in the documentation that says it is thread safe,
then developers of that method took precautions to make sure it is.

"cj" <[e-mail] amwrote in message
news:un******** ******@TK2MSFTN GP02.phx.gbl...

>Ok.

But the act of declaring Public Shared alone doesn't make it threadsafe
does it? I have this class MyThreadCount (see below) which creates public
shared classes but I was told I had to use the synclock to keep multiple
threads from manipulating the count at the same time. Is this true?

Public Class MyThreadCount

Private Shared m_lock As New Object
Private Shared m_threadcount As Int32 = 0

Public Shared Sub Increment()
SyncLock (m_lock)
m_threadcount += 1
End SyncLock
End Sub

Public Shared Sub Decrement()
SyncLock (m_lock)
m_threadcount -= 1
End SyncLock
End Sub

Public Shared ReadOnly Property ThreadCount() As Int32
Get
Dim _count As Int32
SyncLock (m_lock)
_count = m_threadcount
End SyncLock
Return _count
End Get
End Property
End Class
Travers Naran wrote:

>>cj wrote:
Sorry but to me these two situations sound the same. I don't understand
what the difference is. To use a class I have to create an instance of
it, right?
No.

There are two types of methods on classes. Instance methods and Shared
methods.

An instance method is declared:
Public Sub Foo()
...
End Sub

A shared method is declared:
Public Shared Sub Bar()
...
End Sub

If the class is called Foobar, then to call Foo:

dim o as new Foobar
o.Foo()

Notice I had to create an instance first. But to call Bar:

Foobar.Bar()

I don't have to create an instance because it is _shared_. I simply
use the name of the class. In C++-speak, it's a static method. In OOP
speak, a _class_ method.

Example in the framework:
Int32.Parse(" 42")

[Marina Levit [MVP]]

There is usually an icon in the documentation to indicate that a method is
shared. When you look at the help for that method, it says it is shared
there as well.

A lot of these classes don't actually have any useful shared methods that
you would ever call. You would always end up creating an instance of the
class, at which point those methods on that object are not thread safe.

Some classes might actually have shared methods that you would want to call.
It all depends on the class.

"cj" <[e-mail] amwrote in message
news:%2******** ********@TK2MSF TNGP03.phx.gbl. ..

Ok, believe it or not were making progress. I think between my
threadcount class and Travers examples I'm getting an idea of how to write
a class that's threadsafe or not.

But for MS classes... Right now I'm looking at the Queue class and it
says, "Public static (Shared in Visual Basic) members of this type are
safe for multithreaded operations." How do I tell which of the methods
listed under Queue Members are public static? They list Public
Constructor, Public Properties, Public Methods, and protected Methods. I
see the thread safe message a lot and I would like to know what exactly
it's saying is and isn't threadsafe about the class or how I use it. If
there is a better MS class example than the Queue class feel free to point
it out.
Marina Levit [MVP] wrote:

>No, having a method declared as Shared does not automatically make it
thread safe.

But if there is a note in the documentation that says it is thread safe,
then developers of that method took precautions to make sure it is.

"cj" <[e-mail] amwrote in message
news:un******* *******@TK2MSFT NGP02.phx.gbl.. .

>>Ok.

But the act of declaring Public Shared alone doesn't make it threadsafe
does it? I have this class MyThreadCount (see below) which creates
public shared classes but I was told I had to use the synclock to keep
multiple threads from manipulating the count at the same time. Is this
true?

Public Class MyThreadCount

Private Shared m_lock As New Object
Private Shared m_threadcount As Int32 = 0

Public Shared Sub Increment()
SyncLock (m_lock)
m_threadcount += 1
End SyncLock
End Sub

Public Shared Sub Decrement()
SyncLock (m_lock)
m_threadcount -= 1
End SyncLock
End Sub

Public Shared ReadOnly Property ThreadCount() As Int32
Get
Dim _count As Int32
SyncLock (m_lock)
_count = m_threadcount
End SyncLock
Return _count
End Get
End Property
End Class
Travers Naran wrote:
cj wrote:
Sorry but to me these two situations sound the same. I don't
understan d
what the difference is. To use a class I have to create an instance
of
it, right?
No.

There are two types of methods on classes. Instance methods and Shared
methods.

An instance method is declared:
Public Sub Foo()
...
End Sub

A shared method is declared:
Public Shared Sub Bar()
...
End Sub

If the class is called Foobar, then to call Foo:

dim o as new Foobar
o.Foo()

Notice I had to create an instance first. But to call Bar:

Foobar.Bar()

I don't have to create an instance because it is _shared_. I simply
use the name of the class. In C++-speak, it's a static method. In OOP
speak, a _class_ method.

Example in the framework:
Int32.Parse( "42")