[armedbear-devel] threads:interrupt-thread

[Carlos Ungil]

Hello Erik,

I don't know how to debug java processes but I have an intuition about why those threads are not interrupted: they're never waiting.

See the example below: an interruption scheduled for the interpreter thread is only executed when I put the thread to sleep (and if the garbage collector runs in the meantime it's lost).

The reason why I cared about being able to interrupt the main thread was to run finalizers from there, to avoid concurrency issues in a foreign library. In the end I implemented an alternative solution using locks so I'm not really concerned about this problem anymore.

Regards,

Carlos

CL-USER(1): (let ((main (threads:current-thread)))
  (threads:make-thread (lambda ()
			 (threads:interrupt-thread main (lambda () (print "Hi there!"))))))
#<THREAD {3AF6EA95}>

CL-USER(2): (* 2 2)
4

CL-USER(3): (sleep 1)

"Hi there!"
NIL

CL-USER(4): (let ((main (threads:current-thread)))
  (threads:make-thread (lambda ()
			 (threads:interrupt-thread main (lambda () (print "Hi there!"))))))
#<THREAD {CE5A31A}>

CL-USER(5): (gc)
462843184

CL-USER(6): (sleep 1)
NIL


On 06/09/2013, at 21:49, Erik Huelsmann <ehuels at gmail.com> wrote:

> Hi Carlos,
> 
> > is there a reason why interrupt-thread doesn't seem to run the requested function in some cases? The following code tries to run a function in each existing thread (the variable *output* logs the calls that we try to run and the ones that are actually run).
> 
> Looking at your  code, there may be multiple causes for the strings not showing up in the output. Frst of all, there's a problem with concurrency in your code: pushing into the *output* variable across threads isn't thread safe. The other reason for the code not being executed could be a bug: the code "checks manually" whether the thread interrupt has been invoked and executes the function(s) handed over. Maybe these threads land in loops that do not check this condition.
> > (defvar *output*)
> >
> > (defun test-run ()
> >   (setf *output* nil)
> >   (threads:mapcar-threads
> >    (lambda (thread)
> >      (push (format nil "~A : calling" thread) *output*)
> >      (threads:interrupt-thread thread
> >       (lambda () 
> > (push (format nil "~A : running" thread) *output*))))))
> >
> > (defun test-report ()
> >   (format t "~{~A~%~}" (reverse *output*)))
> >
> > Running in the command line:
> 
> [snip]
> 
> >
> > I can understand that the thread "TEST-RUN" that I create to run the function might disappear before it gets to run the function as requested, or maybe the reason is that a thread can't interrupt itself by design... But why doesn't the thread "interpreter" run the function?
> >
> > Running in slime there are many threads present, and most of them will respond as expected. But "TEST-RUN", "interpreter" and "reader-thread" won't.
> 
> Can you interrupt the reader-thread and interpreter thread in a java debugging environment and tell me what the stack trace is when you send the signal that isn't being processed? Maybe the answer turns out to be really obvious.
> Thanks!
> 
> Bye,
> 
> 
> Erik.
>