Work with Thread::Semaphore.Limit the number of threads - multithreading

Question

I can not deal with Semapfor. As they run, so they passed on one stream? In fact, the variable $ n Randomnaya taken from 0 to 2. When the condition that $ n = $ it (# $ num - stream number), the message, then the flow $ num smokes. Others (# where $ n! = $ Num) should be skipped. The message "trade does not smoke." The situation is that it passes all the threads at once and where it is not necessary, he deduces that the flow $ num smokes (# in fact gives the correct number, but it does not fit the situation).
#! usr/bin/perl -w
use strict;
use warnings;
use 5.010;
use threads;
use threads::shared;
use Thread::Semaphore;
my $sem = Thread::Semaphore->new(1);
my $n = int rand(3);
say $n;
my $shr : shared = 1;
my $threads = 2;
my #threads;
for my $t ( 0 .. $threads ) {
push #threads, threads->create( \&smoke, $t );
}
# Дожидаемся окончания работы всех потоков
for my $t (#threads) { $t->join(); }
sub smoke {
my $num = shift;
$sem->down;
say "+Thread $num started";
sleep 1;
if ( $num = $n ) { sleep 2; say "Thread $num -- smoke"; }
say "-Thread $num done. \n";
if ( $num != $n ) {
say "-Thread $num dont smoke!. \n";
}
{ lock($shr); $shr++ }
$sem->up;
return;
sleep 1;
}

Answer 1

Semaphores are nothing more complicated than a shared counter.
When you call down() the counter is decreased - and it will block if it cannot. If you call up() the count is incremented. (And anything blocking will be released).
However, until that 'block' occurs, the threads can - and will - execute in an undefined order, that you should assume is random. (It isn't entirely, but relying on any particular sequence will create race conditions).
It's not complicated, but one of the things that can trip you up is buffering - print statements in threads may get buffered, so appear to arrive in strange order.
E.g.:
#! usr/bin/perl -w
use strict;
use warnings;
use 5.010;
use threads;
use threads::shared;
use Thread::Semaphore;
my $sem = Thread::Semaphore->new(1);
#turn off buffering
$|++;
sub wait_for_sem {
print threads -> self -> tid. ": waiting for semaphore\n";
$sem -> down();
print threads -> self -> tid. ": got semaphore\n";
sleep rand 3;
print threads -> self -> tid. ": releasing semaphore\n";
$sem -> up;
}
threads -> create ( \&wait_for_sem ) for 1..100;
foreach my $thr ( threads -> list ) {
print "Waiting for ".$thr->tid." to join\n";
$thr -> join;
print "Joined ".$thr->tid."\n";
}
I think buffering is what's going wrong with your code - try it with $|++.