Kill Channel List

killchanlist

package main

import (
	"log"
	"sync"
)

type List struct {
	sync.Mutex
	chans []chan struct{}
}

func (l *List) Inc(cnt int) []chan struct{} {
	var s []chan struct{}
	for n := 0; n < cnt; n++ {
		ch := make(chan struct{}, 1)
		s = append(s, ch)
	}
	l.Lock()
	defer l.Unlock()
	l.chans = append(l.chans, s...)
	return s
}

func (l *List) Dec(cnt int) (r []chan struct{}) {
	l.Lock()
	defer l.Unlock()
	l.chans, r = l.cut(l.chans, len(l.chans)-cnt, len(l.chans))
	return r
}

func (l *List) Len() int {
	log.Println(l.chans)
	return len(l.chans)
}

func (l *List) cut(a []chan struct{}, offset, length int) ([]chan struct{}, []chan struct{}) {
	var b []chan struct{} = make([]chan struct{}, (length - offset))
	copy(b, a[offset:length])

	copy(a[offset:], a[length:])
	for k, n := len(a)-length+offset, len(a); k < n; k++ {
		a[k] = nil // or the zero value of T
	} // for k

	return a[:len(a)-length+offset], b
}

func main() {

	quit := make(chan bool)

	myList := &List{}

	newChans := myList.Inc(10)
	log.Println(newChans)

	// Hook up workers here...
	for _, ch := range newChans {
		go worker(ch)
	}

	killSlice := myList.Dec(5)
	log.Println(killSlice)

	// Send kill signal over this slice of chans
	for _, kc := range killSlice {
		kc <- struct{}{}
	}

	log.Println(myList.Len())

	<-quit
}

func worker(c chan struct{}) {
	for {
		select {
		case <-c:
			log.Println("Dying gracefully")
		default:
		}
	}
}