Forum: Ruby Keep thread in memory

Announcement (2017-05-07): www.ruby-forum.com is now read-only since I unfortunately do not have the time to support and maintain the forum any more. Please see rubyonrails.org/community and ruby-lang.org/en/community for other Rails- und Ruby-related community platforms.
Craig Williams (Guest)
on 2009-03-15 23:38
(Received via mailing list)
Hi,

I'm writing a simple UDP listening server. It works great using this

PORT = 1234
server = UDPSocket.open
server.bind("127.0.0.1", PORT)

server_thread = Thread.start(server) do |server|
 100.times { #do something }
end

server_thread.join

The above was based off some code from the Ruby 1.9 book - I have a
problem
now trying to take it a step further.

How do I get the above to run permanently or until some other condition
besides (100) is reached?

When I run this on my remote server over SSH it works but if I ctrl-z or
exit ssh, the process seems to be in memory but isn't actually working.
I'd
like to run it and have it go into memory until it is killed and return
me
to the ssh command.

I tried leaving off the server_thread.join but then it just quits. Could
someone explain exactly what Thread.start is doing here.

thanks!
-c
Michael M. (Guest)
on 2009-03-15 23:52
(Received via mailing list)
Craig Williams wrote:
> end
> exit ssh, the process seems to be in memory but isn't actually working. I'd
> like to run it and have it go into memory until it is killed and return me
> to the ssh command.
>
> I tried leaving off the server_thread.join but then it just quits. Could
> someone explain exactly what Thread.start is doing here.
>
> thanks!
> -c
>
>
It does exactly what you think it will do.  It starts a thread, runs the
block and exits when the block is completed.
If you want it to wait around for things to happen, like something being
fed down a socket, you just need to make a call to an async function,
like IO.read(server) which will wait around until there is something to
read.

I can't explain why your process is still in memory.  To me, it should
have exited and dropped off the face of the planet.

=======================================================================
This email, including any attachments, is only for the intended
addressee.  It is subject to copyright, is confidential and may be
the subject of legal or other privilege, none of which is waived or
lost by reason of this transmission.
If the receiver is not the intended addressee, please accept our
apologies, notify us by return, delete all copies and perform no
other act on the email.
Unfortunately, we cannot warrant that the email has not been
 altered or corrupted during transmission.
=======================================================================
Robert K. (Guest)
on 2009-03-16 00:26
(Received via mailing list)
On 15.03.2009 22:35, Craig Williams wrote:
> server_thread = Thread.start(server) do |server|
>  100.times { #do something }
> end
>
> server_thread.join

First of all, why are you using a thread here?  Do you have other work
that needs to be done concurrently?

> The above was based off some code from the Ruby 1.9 book - I have a problem
> now trying to take it a step further.
>
> How do I get the above to run permanently or until some other condition
> besides (100) is reached?

Depends on the condition.  If you want this to run indefinitely you can
simply do

loop do
   ...
end

> When I run this on my remote server over SSH it works but if I ctrl-z or
> exit ssh, the process seems to be in memory but isn't actually working. I'd
> like to run it and have it go into memory until it is killed and return me
> to the ssh command.

"Go into memory"???  All programs are executed in memory.  What you
probably rather need is a demon, i.e. a program that continues to work
even if the terminal gets removed (ssh close).

> I tried leaving off the server_thread.join but then it just quits. Could
> someone explain exactly what Thread.start is doing here.

In your example above the thread is completely superfluous since you do
not do anything concurrently.  A plain old infinite loop would do the
same job.  Basically your code is equivalent to

PORT = 1234
server = UDPSocket.open
server.bind("127.0.0.1", PORT)

100.times { #do something }

Kind regards

  robert
Craig Williams (Guest)
on 2009-03-16 00:33
(Received via mailing list)
thanks Robert,

A simple loop..do will work and yes, a daemon is what I want to create.
I'll
look it up and see if I can find some theory around this in Ruby. I
should
have said a TSR right ;-)

Is it good practice in Ruby to sleep when in an infinite loop? or will
Ruby
protect me from that kind of issue?

thanks,

-c


On Sun, Mar 15, 2009 at 6:22 PM, Robert K.
Michael L. (Guest)
on 2009-03-16 00:43
> Is it good practice in Ruby to sleep when in an infinite loop? or will
> Ruby

Dunno why you would sleep a program when you don't have to o_O

sleeping is most useful when working with Threads, though in some cases
there may be a reason you'd wish to have the program wait for a few
seconds I suppose.

- Mac
Tommy N. (Guest)
on 2009-03-16 01:07
(Received via mailing list)
On Mar 15, 2009, at 10:35 PM, Craig Williams wrote:

> end
>
> When I run this on my remote server over SSH it works but if I ctrl-
> z or
  ctrl-z suspends the current job, and moves it to the background
>
> thanks!
> -c

-----------------------------------
See the amazing new SF reel: Invasion of the man eating cucumbers from
outer space.
On congratulations for a fantastic parody, the producer replies :
"What parody?"

Tommy N.
removed_email_address@domain.invalid
Craig Williams (Guest)
on 2009-03-16 01:58
(Received via mailing list)
thanks everyone - I found the Daemons wrapper and a simple loop was well
simple :) and it works great.

I also know what ctrl-z does now .... learning is fun ;-)

-c
This topic is locked and can not be replied to.