You shouldn't need the call to cond_signal(...) unless you are trying to deliberately meter the flow of your threads (a bad idea in most cases), or possible if you are going to need to re-access the same variable later at the same scope, Otherwise, and in most cases, you only need to let the lock go out of scope for the shared variable to become unlocked.

Also, you (probably) shouldn't be locking the whole array, just the element that you want to access.

sub run {
    my $self          = Foo->new(@_);
    my $id            = $self->{id};
    ...

    print "Hello from thread $id.\n";
    lock($aryItems[$id]);
    print "Item $aryItems[$id]\n";
    delete $aryItems[$id];

    # The lock is removed once when the function returns
    return 1; 
}
[download]

There is a caveat of using delete, unlike with splice the array element is not removed, it is effectively just undefed.

It is difficult to be more specific without understanding more about what it is that your code is trying to achieve. I realise that you probably just exploring the possibilities at the moment, but there are different ways of using threads depending upon your ultimate goal.

Hi,
Thank you for your reply. This part of the system I am working on periodically reads a directory, builds an array, and threads calls to process each file in the array.


Given n number of elements in the array, I have limited the number of threads I am using so the process can send 1..$threads thread per file in given a subsets of the files. (I am trying to give each thread a unique index into the array so there are no deadlocks.) The code is something like this:

# PSEUDOCODE
...

our $MAXTHREADS = 5;
our @aryItems : shared;
...

main();

sub main {...}

sub process {
        my $threads = 0;
        my $files = (@aryItems);

        if ($files > $MAXTHREADS) {
            $threads = $MAXTHREADS;
        }
        
        initThreads($threads, ...);
...
}

sub initThreads {
    ...
    my $threads = 0;
    ...

    ($threads, ...) = @_;

    our @threads = ();
    
    for (0..$threads - 1) {
        push @threads, threads->new(
                                   \&Foo::run,
                                    id => $_,
                                    ...
                                   );
    }
}
...
####
Foo class
####
package Foo;
use threads;
use threads::shared;
...

sub new{...};
sub run{<processing and locking code goes here>};
[download]




-P0w3rK!d

BrowserUK,
This did not work. I locked a single array element as you suggested.

Hello from thread 0.
Item 400.xml
thread failed to start: lock can only be used on shared values at foo.
+pl line 1036.
Hello from thread 1.
Item 1159.xml
thread failed to start: lock can only be used on shared values at foo.
+pl line 1036.
Hello from thread 2.
Item 1175.xml
thread failed to start: lock can only be used on shared values at foo.
+pl line 1036.
[download]




-P0w3rK!d :)