"if I do not add the last line of code, the main thread do not spawn enough 'worker' threads at the first time, only 2 ones created, but it should be 8 at this time. I guess the current thread is switched to the main thread at that time so I add threads->yield(), then one more 'worker' threads is spawned at the first time, but it is still not what I want. At last I add sleep(1), it is OK then, why?"

You are misunderstanding what is going on here. Without the sleep, all the threads do get started--it just takes a minute or so for it to happen.

The reason for the delay comes down to the locking you are using, but I'll come back to that. There is a far more fundamental issue to deal with first. That of how you are creating your worker threads:

You are spawning each thread, using the thread handle return to obtain the thread ID, and using that to set up the control structures used by the thread:

    if ( my $thread = threads->new( \&do_worker ) ) {
        my $t = $thread->tid;
        lock %{ $stat{'work'} };
        $stat{'work'}{ $t } = &share( {} );
        $stat{'work'}{ $t }{'stat'} = 'idle';
[download]

But, the first thing your thread does is attempt to use the control structure:

    sub do_worker {
        my $t = threads->self()->tid();
#        sleep(1);
        my $c;
LOOP:    while ( !$stat{'work'}{$t}{'stat'} ne 'done' ) {
[download]

Which your main thread hasn't yet created!

And, you are also accessing that shared control structure without having locked it!

To correct these problems, you could move the per-thread control structure creation inside the thread itself, and apply locking to the accesses:

    sub do_worker {
        my $t = threads->self()->tid();
        {
            lock %{ $stat{'work'} };
            $stat{'work'}{ $t } = &share( {} );
            $stat{'work'}{ $t }{'stat'} = 'idle';
        }
        my $c;
LOOP:    while ( do{ lock %{ $stat{'work'}{$t} }; $stat{'work'}{$t}{'s
+tat'} } ne 'done' ) {
...
    if ( my $thread = threads->new( \&do_worker ) ) {
        my $t = $thread->tid;
        trc 'dbg',  'new worker created';
        $thread->detach;
...
[download]

But that raises another question: As these are 'per-thread' control structures, why are you having to lock them?

Looking at the places outside of the worker thread where they are accessed, it all happens in you main thread loop. But your main thread loop is controlled by a message queue, and the messages are being sent from the worker threads.

So the question then becomes: why send a message from a worker thread to the main thread to have it modify the shared, per-thread control structures when the worker threads could make those modifications directly?

Indeed, the more I think about that logic, the more questionable the reasons for having a queue at all. There are other questions about your architecture that need answering, but I'll get back to them later.

LOOP:    while ( $stat{'work'}{$t}{'stat'} ne 'done' ) {
            {
                lock %{ $stat{'lock'} };
                $c = $listener->accept() or next LOOP;
            }
[download]

timeout => 10,</code>. 

<P>If you remove the <c>sleep 1;
[download]

            lock %{ $stat{'work'} };
...
            $stat{'work'}{$t}{'stat'} = $s;
            $stat{'work'}{$t}{'time'} = time();
            $stat{'work'}{$t}{'work'}++ if $s eq 'idle';
[download]

            lock %{ $stat{'work'}{$t} };
...
            $stat{'work'}{$t}{'stat'} = $s;
            $stat{'work'}{$t}{'time'} = time();
            $stat{'work'}{$t}{'work'}++ if $s eq 'idle';
[download]