public class Program
{
   public static void Main(string[] args)
   {
      var toSortInts = new[] {1, 8, 5, 22, 3};
      var sorted = toSortInts.Select(curInt => new Task(() =>
         {
            Thread.Sleep(curInt);
            Console.WriteLine(curInt);
         }))
         .ToList();

      sorted.ForEach(t => t.start());

      Console.ReadLine();
   }
}

L>public class Program
L>{
L>   public static void Main(string[] args)
L>   {
L>      var toSortInts = new[] {1, 8, 5, 22, 3};
L>      var sorted = toSortInts.Select(curInt => new Task(() =>
L>         {
L>            Thread.Sleep(curInt);
L>            Console.WriteLine(curInt);
L>         }))
L>         .ToList();

L>      sorted.ForEach(t => t.start());

L>      Console.ReadLine();
L>   }
L>}
L>

#include <iostream>
#include <vector>
#include <thread>
#include <chrono>
#include <algorithm>
 
 
template< typename It >
void sleepSort( const It& begin, const It& end )
{
    if ( begin == end )
        return;
    const auto max = *std::max_element( begin, end );
    const auto min = *std::min_element( begin, end );
 
    for ( auto it = begin; it != end; ++it )
    {
        std::thread( [min, i = *it]
        {
            std::this_thread::sleep_for( std::chrono::milliseconds( i - min ) );
            std::cout << i << std::endl;
        } ).detach();
    }
    std::this_thread::sleep_for( std::chrono::milliseconds( max - min + 1 ) );
}
 
int main( int argc, char *argv[] )
{
    std::vector<int> v = { 20, 5, 15, 10, -5, };
    sleepSort( v.begin(), v.end() );
 
    return 0;
}

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    sleepSort([]int{20, 5, 15, 10, -5})
}

func sleepSort(v []int) {
    if len(v) == 0 {
        return
    }

    min := v[0]
    for _, e := range v {
        if e < min {
            min = e
        }
    }

    wg := sync.WaitGroup{}
    wg.Add(len(v))

    for _, e := range v {
        go func(e int) {
            defer wg.Done()

            time.Sleep(time.Millisecond * time.Duration((e - min)))
            fmt.Println(e)
        }(e)
    }

    wg.Wait()
}