This would have worked if you were using the same JVM as EricF
suggested. A later message mentions that you are creating a second
object in a second shell indicating to me that you are using two JVM
instances. This approach doesn't work because each JVM instance has its
own environment and they are not shared.

What you want is that when a second "object" is "created" it really
accesses the first object created regardless of whether that happens in
the same JVM or not. What about if you create a Counter object in a
second computer all together? Should it connect to the first Counter
object created (on some other unknown computer)?

You are trying to solve a very hard problem here. As ugly a solution as
using the file system as memory might be the easiest solution for single
computer processing. Make sure you use appropriate locking mechanisms
since two JVM processes (and hence two instances of Counter) could try
to access the file at the same time.

You also don't know when the Counter object "dies". Is the Counter alive
only when there are instances of it alive or is it alive regardless? You
have a lot of things to think about here.

RMI, Beans, CORBA, COM, .NET, web services, etc. all exists as
frameworks to help formulate solutions to this very hard problem. Most
of these (if not all) will probably be too complex for what you are
doing. Then again, locking access to a file is hard as well.

--
Edwin

Shouldn't this be public? How else can it be accessed from the
outside? Or did i miss some trick? :)

Thanks for responding, but this doesn't quite do the trick. I think i
have to elaborate on what i want. From what i wrote previously, i
don't think it came out clearly.

I have a package, foo, containing the Counter class. Now i have a
class, A, which does: import foo.Counter;

A has a main method, which starts an instance of itself, wrapped in a
Thread. The Thread works as a ticker, counting the shared object
Counter up one.

Now i start another instance of A, from another shell. Since this does
the exact same thiing as the first A, it also imports foo.Counter.
What i want is for the second instance to start counting from where
the first instance was at when the second was started.

An example printout would be like this:

(Start A1, first instance of A, with java A)
A1: count: 1
A1: count: 2
A1: count: 3
(start A2, second instance of B, in another shell, with java A)
A2: count: 4
A1: count: 5
A2: count: 6
A1: count: 7

And so on...

From what i tried, A2 just starts counting from 1, and A1 just keeps
counting.

Any suggestions on how to crack this one? :)

- Carsten H. Pedersen