Re: What's the connection between objects and threads?
On May 21, 2:26 am, I V <ivle...@gmail.com> wrote:
On Tue, 20 May 2008 16:34:04 -0700, Szabolcs Ferenczi wrote:
2) In procedural languages if you introduce a keyword for a Critical
Region, you must also give some means to associate which shared
variables are involved. So, fixing your example, if there is a shared
resource `m' you can define a critical region using a keyword like
`synchronized' such as this:
shared int m; // the `shared' keyword marks the shared variable =
....
synchronized(m) {
// here you can access `m'
}
Now the compiler can make sure that `m' is accessed within Critical
Regions and only within Critical Regions.
Can you see the difference between the language level means and the
library level means?
Lets imagine, instead of your syntax, we use this syntax:
shared<int> m;
{
synchronized<int> s(m);
// Here you can access the shared int 'm' through the obje=
ct 's'
}
Again, the compiler can ensure that the shared state is only accessed
within a critical region (which, in this case, is equivalent to a block
containing the construction of the relevant synchronized<T> object). But
my proposed syntax can be implemented just as well with a library
solution as with a keyword based one, if the language provides certain
guarantees. So what's the difference?
It is not about syntax but first of all it is about semantics.
However, without syntax you cannot talk about semantics.
In your version `shared' and `synchronized' are keywords, aren't
they?
If yes, you already introduced keywords for the language which the
compiler can recognise. How would you describe the semantics of these
keywords? What is the role of object `s'?
If not, it can really be implemented with a library solution but the
compiler will not be able to identify the block what you mean as the
Critical Region and hence it cannot ensure for you that the intended
shared variable is only accessed within Critical Region.
Is it clear to you?
(Note that the role of "object 's'" is not clear in your proposal, see
"the shared int 'm' through the object 's'".)
Best Regards,
Szabolcs