Видимо, за отведённый квант времени поток успевает отсчитать свои 1000 инкрементов почти всегда

Брр, нет, мозги в трубочку. Квант был бы уместен на SMP, а с 16-ю ядрами какой квант нафиг, треды реально параллельно должна исполняться. Наверное, правильно сначала чтобы все потоки засинкались. А здесь c += 1 не успевает отщёлкаться ещё до того, как новый поток будет создан spawn;ом

Да, вот такая намного нагляднее получилось:

c = 0

ch_sync = (0..9).map { Channel(Nil).new }
ch_fin =  (0..9).map { Channel(Nil).new }
10.times do |ix|
  spawn do
    ch_sync[9 - ix].receive
    1000.times { c += 1 }
    ch_fin[ix].send(nil)
  end  
end

ch_sync.each {|cs| cs.send(nil) }
ch_fin.each  {|cf| cf.receive }

puts c

А ченнелы зачем?

Я бы вообще начал с c = c + 1

ch_sync чтобы примерно в одно время все потоки начали инкрементить c
Другой - чтобы подождать, когда все доинкрементят. Можно было ch_fin сделать просто одним каналом, но хотелось разнообразия :)

Там барьер в крайнем случае нужен, а не это все

В случае с инкрементом даже не барьер, а просто сделать столько операций, чтобы точно создание нового треба на этом фоне было незаметной операцией

А барьер-то на чём делать?

Там есть только мутексы и каналы, барьеров что-то в stdlib не видел

Если сделать бешеное количество инкрементов - будет менее наглядно-поучительный результат, ну и не мгновенно отрабатывать будет.
Хотя вообще нужно в процентах реального приращения относительно "наивно ожидаемого" вывести :)

Попробую сделать примитив "барьер" на Crystal. Но всё равно всё сводится к тому, что нужно раздать каждому потоку по залоченному мутексу, а потом одновременно у всех потоков разлочить его. Причём совсем одновременно не получится снять.

Времени в конкарренси не существует вообще, только последовательности, при чем иногда гипотетические

Такое конкаренси, где один файбер на поток, вполне можно использовать как просто параллельную многопоточность

Демонстрация того, как работает канал с буфером: получатели могут из него вытягивать данные сразу, а не строго после того, как буфер будет забит (я такие редко использовал, мне было интересно).

ch = Channel(Int32).new(10)
cf = Channel(Nil).new

10.times do |ix|
  spawn do
    puts "#{ix} before rcv"
    ch.receive
    puts "rcvd #{ix}"
    cf.send(nil)
  end
end

sleep 0.2

10.times do |ix|
  puts "sending #{ix}"  
  ch.send(ix)
  Fiber.yield
end

10.times { cf.receive }

Интересно, что если делать просто ch.send(ix) без Fiber.yield - не происходит переключения контекста (не отдаётся управление в event loop) и никто в других Fiber'ах не получает значения

Сделал с наивной реализацией класса "Barrier":
https://play.crystal-lang.org/#/r/bmp0

Я не знаю как именно в этом рантайме все будет себя вести, но в любом другом достаточно будет взять на запись rwlock, наспавнить воркеров, которые запросят тот же лок на чтение, поспать в основном потоке секунду и потом снова попросить на запись
Эквивалент с семафорами ещё может быть.
Только все равно это не принципиально и лишнее если сам пруф неконкурренсиспособности выполняется достаточно долго сам по себе и вся задача исключительно увидеть аномалию.

есть яп, на котором ты не пишешь?

Да я даже плюсов не знаю

не засчитано