协作线程，没有分配

Question

首先，我喜欢滚动我自己的，这是一个学习目的的练习，但我希望最终从这个练习中获取信息，并在这里实现一些包含行为的宏。这就是为什么我使用大量的let，因为还没有最终确定和定义太“沉重”。

因此，您可以使用call/cc来实现各种不同的协作线程结构，而im使用的线程的模型通常是：

(let ((generic-thread
       (lambda (cc)
         (let loop ((cc cc))
           (printf "doing stuff~N")
           (loop (call/cc cc)))))) ;this is the magic, it calls the calling continuation
  (let loop ((its 0)               ;and then loops with the result of that
             (cc generic-thread))  ;so when its resumed, it still has its new state
    (if (< its 10)
        (loop (+ its 1) (call/cc cc))))) ;just repeats the procedure for the demonstration

到目前为止，这实际上运作得很好。

因此，在我的问题中，我觉得我已经确定了几个基本的情况，一个退出子句的线程，那些没有它们的线程，以及不能被恢复的线程，或者一个镜头(本质上只是一个函数调用，但我想保持一致，所以它必须在一个“线程”中，而不仅仅是一个函数调用中)。

(let ((spawn-thread
       (lambda (it . args)
         (call/cc (apply it args))))

      (main 
        (lambda (label reps . sequence)
         ;for consistency, main is also a thread, but does not need to be
         ;this will take a number of repetitions, and a sequence of continuations
         ;to call, pushing the continuation returned from the top continuation in 
         ;sequence to the end, and then calling the loop again
          (lambda (cc)
            (let loop ((sequence sequence) (state 0))
              (printf "IN MAIN THREAD STATE: ~A~N---" state)
              (if (< state reps) ;this is essentially a queue but without assignment
                  (loop `(,@(cdr sequence) ,(call/cc (car sequence))) 
                         (+ state 1)))))))

      (with-exit 
       (lambda (label data) 
       ;thread with exit case
         (lambda (cc)
           (let loop ((cc cc) (done (lambda () #f)) (state 0))
             (cond ((done) (cc data)) ;if done was replaced with something else that                                   
                                      ;could at some point return true, this is where
                                      ;the thread would exit
                   (else              
                     (printf "IN THREAD ~A TYPE: WITH-EXIT STATE: ~A~N" label state)
                     (loop (call/cc cc) done (+ state 1))))))))

      (no-exit 
        (lambda (label data) 
        ;no exit case, can be resumed arbitrarily
          (lambda (cc)
            (let loop ((cc cc) (state 0))
              (printf "IN THREAD ~A TYPE: NO-EXIT STATE: ~A~N" label state)
              (loop (call/cc cc) (+ state 1))))))


      (no-reps 
        (lambda (label data) 
        ;breaks it for some reason? 
        ;would be called, do its stuff and then
        ;go back to the calling continuation
         (lambda (cc)               
           (printf "IN THREAD ~A TYPE: NO-REPS~N" label)
           (call/cc cc)))))

  (spawn-thread main 'main 10
        (spawn-thread with-exit 1 '())
        (spawn-thread no-exit 2 '())
        (spawn-thread with-exit 3 '())
        ;(spawn-thread no-reps 4 '())) uncomment to see error
        ))

为什么不做代表？为什么作为主线程之一运行它会导致无限循环？

示例输出的注释行：

IN THREAD 1 TYPE: WITH-EXIT STATE: 0
IN THREAD 2 TYPE: NO-EXIT STATE: 0
IN THREAD 3 TYPE: WITH-EXIT STATE: 0
IN MAIN THREAD STATE: 0
---IN THREAD 1 TYPE: WITH-EXIT STATE: 1
IN MAIN THREAD STATE: 1
---IN THREAD 2 TYPE: NO-EXIT STATE: 1
IN MAIN THREAD STATE: 2
---IN THREAD 3 TYPE: WITH-EXIT STATE: 1
IN MAIN THREAD STATE: 3
---IN THREAD 1 TYPE: WITH-EXIT STATE: 2
IN MAIN THREAD STATE: 4
---IN THREAD 2 TYPE: NO-EXIT STATE: 2
IN MAIN THREAD STATE: 5
---IN THREAD 3 TYPE: WITH-EXIT STATE: 2
IN MAIN THREAD STATE: 6
---IN THREAD 1 TYPE: WITH-EXIT STATE: 3
IN MAIN THREAD STATE: 7
---IN THREAD 2 TYPE: NO-EXIT STATE: 3
IN MAIN THREAD STATE: 8
---IN THREAD 3 TYPE: WITH-EXIT STATE: 3
IN MAIN THREAD STATE: 9
---IN THREAD 1 TYPE: WITH-EXIT STATE: 4
IN MAIN THREAD STATE: 10

未评论：

IN THREAD 1 TYPE: WITH-EXIT STATE: 0
IN THREAD 2 TYPE: NO-EXIT STATE: 0
IN THREAD 3 TYPE: WITH-EXIT STATE: 0
IN THREAD 4 TYPE: NO-REPS
IN MAIN THREAD STATE: 0
---IN THREAD 1 TYPE: WITH-EXIT STATE: 1
IN MAIN THREAD STATE: 1
---IN THREAD 2 TYPE: NO-EXIT STATE: 1
IN MAIN THREAD STATE: 2
---IN THREAD 3 TYPE: WITH-EXIT STATE: 1
IN MAIN THREAD STATE: 3
---IN MAIN THREAD STATE: 0
---IN THREAD 1 TYPE: WITH-EXIT STATE: 1
......... ;profit????

Answer 1

不确定您使用的是哪个实现，但我无法得到无限循环，只需取消对表达式的注释。(我使用了几个R6RS实现，包括Racket。)

为了让事情变得更简单，我已经像这样剥去了您的代码：

#!r6rs
(import (rnrs))

(define (print . args) (for-each display args) (newline))

(let ((spawn-thread
       (lambda (it . args)
         (call/cc (apply it args))))
      (main
       (lambda (label reps . sequence)
         (lambda (cc)
           (print sequence)
           (let loop ((sequence sequence) (state 0))
             (print "IN MAIN THREAD STATE: " state)
             (display  "---")
             (if (< state reps)
                 (let ((next `(,@(cdr sequence) ,(call/cc (car sequence))) ))
                   (loop next (+ state 1))))))))
      (no-reps
       (lambda (label data)
         (lambda (cc)
           (print "IN THREAD "label" TYPE: NO-REPS")
           (call/cc cc)))))
  (spawn-thread main 'main 10
                ;; *1
                (spawn-thread no-reps 4 '())))

重点是*1的返回延续。过程spawn-thread执行no-reps过程，no-reps返回给定的延续，其下一个进程是调用main的spawn-thread。因此，no-reps在这个上下文中实际上所做的是复制主线程。下面的执行结果(在球拍上运行)显示了它：

IN THREAD 4 TYPE: NO-REPS
{#<continuation>}
IN MAIN THREAD STATE: 0
---{#<continuation>}
IN MAIN THREAD STATE: 0
---IN MAIN THREAD STATE: 1
---IN MAIN THREAD STATE: 1
---IN MAIN THREAD STATE: 2
---IN MAIN THREAD STATE: 2
---IN MAIN THREAD STATE: 3
---IN MAIN THREAD STATE: 3
---IN MAIN THREAD STATE: 4
---IN MAIN THREAD STATE: 4
---IN MAIN THREAD STATE: 5
---IN MAIN THREAD STATE: 5
---IN MAIN THREAD STATE: 6
---IN MAIN THREAD STATE: 6
---IN MAIN THREAD STATE: 7
---IN MAIN THREAD STATE: 7
---IN MAIN THREAD STATE: 8
---IN MAIN THREAD STATE: 8
---IN MAIN THREAD STATE: 9
---IN MAIN THREAD STATE: 9
---IN MAIN THREAD STATE: 10
---%