Question

While thinking a little bit about programming in Java/C# I wondered about how methods which belong to objects are represented in memory and how this fact does concern multi threading.

1. Is a method instantiated for each object in memory seperately or do
   all objects of the same type share one instance of the method?
2. If the latter, how does the executing thread know which object’s
   attributes to use?
3. Is it possible to modify the code of a method in
   C# with reflection for one, and only one object of many objects of
   the same type?
4. Is a static method which does not use class attributes always thread safe?

I tried to make up my mind about these questions, but I’m very unsure about their answers.

Answer 1

Each method in your source code (in Java, C#, C++, Pascal, I think every OO and procedural language…) has only one copy in binaries and in memory.

Multiple instances of one object have separate fields but all share the same method code. Technically there is a procedure that takes a hidden this parameter to provide an illusion of executing a method on an object. In reality you are calling a procedure and passing structure (a bag of fields) to it along with other parameters. Here is a simple Java object and more-or-less equivalent pseudo-C code:

class Foo {
  private int x;

  int mulBy(int y) {
    return x * y
  }
}

Foo foo = new Foo()
foo.mulBy(3)

is translated to this pseude-C code (the encapsulation is forced by the compiler and runtime/VM):

struct Foo {
    int x = 0;
}

int Foo_mulBy(Foo *this, int y) {
    return this->x * y;
}

Foo* foo = new Foo();
Foo_mulBy(foo, 3)

You have to draw a difference between code and local variables and parameters it operates on (the data). Data is stored on call stack, local to each thread. Code can be executed by multiple threads, each thread has its own copy of instruction pointer (place in the method it currently executes). Also because this is a parameter, it is thread-local, so each thread can operate on a different object concurrently, even though it runs the same code.

That being said you cannot modify a method of only one instance because the method code is shared among all instances.