DouKaku?

import Control.Concurrent
import Control.Concurrent.QSemN
import System.Environment
import System.Random
import Text.Printf

main = do { a:_ <- getArgs
          ; let n = read a
          ; q   <- newQSemN n
          ; g <- getStdGen
          ; let rs = randomRs (5,15) g
          ; mapM_ (forkIO . work q) (zip [1..n] rs)
          ; waitQSemN q n
          ; putStrLn "All threads finished"
          }

work :: QSemN -> (Int, Int) -> IO ()
work q (i,d) =  waitQSemN q 1
             >> threadDelay (d*10^6) 
             >> signalQSemN q 1
             >> printf "Theread N.o. %d filinshed\n" i

import threading
import time

class workerThread(threading.Thread):
    def __init__(self):
        self.l = threading.Lock()
        self.workque = []
        threading.Thread.__init__(self)
    
    def run(self):
        while(True):
            self.l.acquire()
            if len(self.workque) == 0:
                self.l.release()
                time.sleep(0.001)
                continue
            
            if self.workque[0] == "exit":
                self.l.release()
                break
            else:
                w = self.workque[0]
                self.workque = self.workque[1:]
                self.l.release()
                exec(w)
                    
    def appendTask(self, task):
        self.l.acquire()
        self.workque.append(task)
        self.l.release()

class threadPool(threading.Thread):
    def __init__(self, n):
        self.l = threading.Lock()
        self.task = []
        self.w = []
        self.isExit = False
        for i in xrange(n):
            self.w.append(workerThread())
            self.w[-1].start()
        threading.Thread.__init__(self)


    def run(self):
        while(True):
            self.l.acquire()
            
            if len(self.task) == 0:
                self.l.release()
                if self.isExit:
                    break
                time.sleep(0.001)
                continue

            isAppend = False
            for w in self.w:
                if len(w.workque) == 0:
                    isAppend = True
                    w.appendTask(self.task[0])
                    self.task = self.task[1:]
                    self.l.release()
                    break

            if isAppend == False:
                self.l.release()
                time.sleep(0.001)

        for w in self.w:
            w.appendTask("exit")
        for w in self.w:
            w.join()

    def appendTask(self, task):
        self.l.acquire()
        self.task.append(task)
        self.l.release()
        
    def exit(self):
        self.l.acquire()
        self.isExit = True
        self.l.release()

tp = threadPool(2)
tp.start()

tp.appendTask("print 'hello world'")
time.sleep(1)
tp.appendTask("print 'sleeping...'\ntime.sleep(10)\nprint 'wake up!'")
tp.appendTask("print 'sleeping...'\ntime.sleep(10)\nprint 'wake up!'")

time.sleep(1)
tp.exit()
tp.join()

using System;
using System.Collections.Generic;
using System.Threading;
static class Program {
    static void Main() {
        Console.WriteLine("start.");
        WaitCallback func = delegate(object obj) {   // 実行されるタスク
            Console.WriteLine("start: {0}", obj);
            Thread.Sleep(new Random().Next(5, 10) * 1000);
            Console.WriteLine("finish: {0}", obj);
        };
        List<WaitHandle> waitHandles = new List<WaitHandle>();
        for(int i = 0; i < 10; i++) {
            waitHandles.Add(func.BeginInvoke(i, null, null).AsyncWaitHandle);
        }
        WaitHandle.WaitAll(waitHandles.ToArray());   // メインスレッドはここで待機
        Console.WriteLine("join.");
    }
}

import java.util.*;
import java.util.concurrent.*;

class MeApp {
    public static void main(String[] args) throws Exception {
        final ExecutorService pool = Executors.newFixedThreadPool(3);
        try {
            final ArrayList<Future<?> > futures = new ArrayList<Future<?> >();
            final Random random = new Random();
            for (int i = 0; i < 10; ++i) {
                final int id = i;
                final int wait = 5 + random.nextInt(10);
                futures.add(pool.submit(new Runnable() {
                    public void run() {
                        System.out.format("task %d start (%2d sec)\n", id, wait);
                        try {
                            Thread.sleep(wait * 1000);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                        System.out.format("task %d done\n", id);
                    }
                }));
            }
            for (Future<?> future : futures) {
                future.get(); // wait for task completion
            }
        } finally {
            pool.shutdown();
        }
        System.out.println("completed");
    }
}

import threading
import random
import Queue
import time

class ThreadPool:
    def __init__(self, count):
        self._queue = Queue.Queue(0) # infinite sized queue
        self._threads = [threading.Thread(target=self._run) for _ in xrange(count)]
        for thread in self._threads:
            thread.start()

    def _run(self):
        while 1:
            func = self._queue.get()
            if func is None:
                break
            func()

    def submit(self, func):
        if func is None:
            raise ValueError("None is not allowed here")
        self._queue.put(func)

    def shutdown(self):
        for thread in self._threads:
            self._queue.put(None) # terminator
        for thread in self._threads:
            thread.join()

def create(id, wait):
    def func():
        print "task %d started (%2d sec)" % (id, wait)
        time.sleep(wait)
        print "task %d done" % id
    return func

def main():
    pool = ThreadPool(3)
    try:
        for id in xrange(10):
            pool.submit(create(id, random.randint(5, 15)))
    finally:
        pool.shutdown()
    print "completed"

if __name__ == '__main__':
    main()

| out nThreads |
out := SharedQueue new.
nThreads := 5.
nThreads timesRepeat: [
    [   | secs |
        out nextPut: {#start. (secs :=  (5 to: 15) atRandom)}.
        (Delay forSeconds: secs) wait.
        out nextPut: {#stop. secs}.
    ] copy fixTemps fork].
World findATranscript: nil.
nThreads * 2 timesRepeat: [Transcript cr; show: out next]

"=> #(#start 8)
    #(#start 15)
    #(#start 14)
    #(#start 6)
    #(#start 10)
    #(#stop 6)
    #(#stop 8)
    #(#stop 10)
    #(#stop 14)
    #(#stop 15) "

#!/usr/local/bin/perl
use strict;
use warnings;
use threads;
use Time::Hires qw/sleep/;

my @thr;
for my $i ( 1 .. shift || 10 ) {
    push @thr, threads->create(
        sub {
            my $n = shift;
            my $s = rand(10.0);
            sleep $s;
            warn "$n:slept $s sec.";
        },
        $i
    );
}

1 while threads->list(threads::running);
warn "All Threads Done";

$thr[0]->join();    # on purpose

END {
    $_->is_joinable() and $_->join() for @thr;
}

(defpackage #:doukaku-116 (:use #:cl #:portable-threads))
(in-package #:doukaku-116)

(defun subjob (name)
  (let ((sleep (+ 5 (random 10))))
    (format t "~&~A(~2D sec.) Start.~%" name sleep)
    (sleep sleep)
    (format t "~&~A(~2D sec.) Stop.~%" name sleep)))

(defun main (&rest jobs)
  (do ((ths (mapcar (lambda (exe) (spawn-thread (gensym) exe)) 
                    jobs)))
      ((notany #'thread-alive-p ths)
       (format t "~&All threads finished.~%"))))

import scala.collection.mutable.SynchronizedQueue

implicit def f2r(f:() => unit) = new Runnable{ def run = f() }
class ThreadPool(num:int) {
  type Proc = ()=>unit
  val _queue = new SynchronizedQueue[Option[Proc]]
  val _cs = (1 to num).map{ i => new Thread(() => {
             var flag = true; while(flag){
               var proc:Option[Proc] = Some(()=>{})
               _queue.synchronized {
                 if(!_queue.isEmpty) proc = _queue.dequeue
               }
               proc match {
                 case Some(f) => f()
                 case _ => flag = false
               }
             }
           })}.toList.map{c => c.start;c}

  def submit(f :Proc) = _queue += Some(f)
  def shutdown = {
    _cs.foreach{c => _queue += None }
    _cs.foreach(_.join)
  }
}

import java.util.concurrent.*;
import java.util.*;

public class Sample implements Callable<Void> {
    public static final int NUM_OF_THREADS = 10;
    private static ExecutorService es = Executors.newFixedThreadPool(NUM_OF_THREADS);
    private int sleepTime;

    public static void main(String[] args) throws InterruptedException {
        try {
            List<Callable<Void>> taskList = new ArrayList<Callable<Void>>();
            Random r = new Random();
            for (int i = 0; i < 15; i++) {
                taskList.add(new Sample(5 + r.nextInt(11)));
            }
            es.invokeAll(taskList);
            System.out.println("done.");
        } finally {
            es.shutdown();
        }
    }

    public Sample(int sleepTime) {
        this.sleepTime = sleepTime;
    }

    public Void call() throws Exception {
        Thread.currentThread().sleep(1000 * sleepTime);
        System.out.println