synchronization is not working right between two copies of the same class for member function

I have a global class that was created to hold the references to different
classes and global variables. This global class is initialized by the main
class (some variable are pass in as arguments) and all the other threads do
a "gd = new Global()" to get their own copy of the class (this should be
done by the threads after initialization was done by main). The idea was
that since all the variables are saved in the class as "static" the other
threads would be able to access any variables saved in the global class
without parent class passing down a pointer to the global class reference.
I have found however that is design is not work correctly because one or
more threads are setting the same variables at that same time or
setting/getting a variable at the same time in the global class.

The original coder added while loop (see below) for the members that he want
to be synchronized using a static locking flag, but in the debugger (and in
real life) I can see both threads can see active as false and the while loop
fails to stop one of the threads from executing the members code while the
other is doing it!

static boolean active = false;

void synchronized connect() {
while (active) {
    wait(50);
}
active = true;
member code
active = false;
}

To try and fix the problem I removed the while loop and adding
synchronization to one of the member declarations, but that didn't work
either! I can see the main and one of the child threads calling the
initializing a socket connect member at the same time even after I added the
synchronization to the function declaration. I assume that synchronize will
only work for the same class reference and not between two copies on the
same class. I really don't want to recode the application and pass the
global class reference down to every thread/class that needs to call global
so that synchronization will work, but it looks like that's what I am going
to have to do to get synchronize to work.

Any ideas on how to fix this design problem without a major rewrite?