jamesgoode wrote On 11/19/07 17:57,:
Hi,
First, I apologise if this topic is in the wrong section, I am quite
new to Usenet.
I have a problem with threads. In my program, when a user connects, a
new thread is created, and all of the network interaction is handled
by the thread. I'm trying to code a simple chat server, so when a
user sends a message, I want to call a method in all of the threads of
the same class, to send a message to all of the clients connected to
the server.
As an aside the "thread per connection" model, though
conceptually simple, is not a particularly good one: when
the number of connections becomes large, the amount of time
spent coordinating the activities of all those threads tends
to get out of hand. If you're just starting to learn your
way around Java and threading, fine -- but realize that you
are implementing the moral equivalent of BubbleSort. (The
moral equivalent of Quicksort is, in this case, called a
"thread pool." For future reference.)
But back to the thread-per-connection scheme. How are
you dealing with the fact that input from a chatter and output
to a chatter may be occurring simultaneously? Perhaps you
have two threads per connection, one reading and one writing?
(That's not the only way, nor even usually the best way, but
it is a fairly simple way.) With that structure, one way to
cope is for each writer to have a queue of messages that are
to be sent to its chatter. A writer thread just sits idly
until a message appears on its queue, then it awakens and
sends the message, and then it goes back to wait for another
message.
So, how does a reader dispatch a message to all the
writers and make sure they all wake up to notice it? It
does something like this:
for (ChatWriter w : allChatWriters) {
synchronized (w.queue) { // acquire queue's lock
w.queue.add(theMessage); // queue the message
w.queue.notify(); // awaken writer if asleep
} // relinquish the lock
}
The writer, meanwhile, is doing something like
while (true) {
synchronized (queue) { // acquire my queue's lock
while (queue.isEmpty()) { // anything there?
queue.wait(); // no: drop lock and sleep
}
message = queue.get(); // yes: take message
} // relinquish the lock
sendTheMessage(message); // send to chatter
}
Points to note: First, *nobody* ever touches the queue,
or even so much as looks at the queue, unless the queue's
lock is held. This is fundamental: You must get exclusive
access to the queue so that your attempts to modify it don't
clash with someone else's, and so somebody else doesn't
change it while you're in the middle of trying to grok it.
Second, when wait() returns it does *not* mean that a message
has been queued; it just means that a message *may* have been
queued. That's why the isEmpty() test is inside a while and
not merely an if, so the awakened thread can go back and
check isEmpty() *after* awakening.
If you haven't yet read
http://java.sun.com/docs/books/tutorial/essential/concurrency/index.html
... you should stop now and do so.
--
Eric.Sosman@sun.com