#!/usr/bin/perl
use warnings;
use strict;

use Data::Dumper;

my %h = ( "Event"   => 1,
          "Event\0" => 2,
        );

print Dumper \%h;  # Oops!

$Data::Dumper::Useqq = 1;
print Dumper \%h;
[download]

($q=q:Sq=~/;[c](.)(.)/;chr(-||-|5+lengthSq)`"S|oS2"`map{chr |+ord
}map{substrSq`S_+|`|}3E|-|`7**2-3:)=~y+S|`+$1,++print+eval$q,q,a,
[download]

Another reason to use Data::Dump instead.

Yep Data::Dumper is a good library (thanks) :)

But you can also use Data::Printer which can colored chars, limit the depth levels, set the indent size, multilines...
There are a lot of options.

https://metacpan.org/pod/Data::Printer

Use p instead of print/say.

p $href;
[download]

Hello coffeemaster1, and welcome to the Monastery!

You can see there are multiple duplicate keys here and I wasn't sure if this was just Data::Dumper printing things out weird as this is a shared variable, or it was actually like this. Is this possible in Perl?

No, absolutely not! It’s a sign that something in your code is seriously broken. :-(

I assumed that if it were to happen the "second" key/value pair would overwrite the first.

Yes, that’s exactly what does happen:

15:57 >perl -MData::Dumper -wE "my %h = (a => 7, b => 13); $h{b} = 42;
+ print Dumper(\%h);"
$VAR1 = {
          'b' => 42,
          'a' => 7
        };

15:57 >
[download]

Could this be caused by the use of a shared variable that is being update in one thread and read in another? (I am using locks when reading and writing to the variable).

You are aware that the Perl lock command is advisory only? In your code you lock(%queue_changes);, but you don’t show any corresponding calls to cond_wait, cond_timedwait, cond_signal, or cond_broadcast to make use of the lock. (See threads::shared.)

You should provide a short, self-contained script which exhibits the anomalous behaviour you’re observing. This will help the monks to help you. But it’s likely that the exercise of producing this script will itself enlighten you as to what’s going wrong in your code.

BTW, this line is wrong:

$queue_changes{$event_id} = %type;
[download]

as it puts %type into scalar context and thereby assigns to $queue_changes{$event_id} a fraction such as 6/8.¹ I assume you meant:

$queue_changes{$event_id} = \%type;
[download]

Another point: this code:

$event_id = int(rand(25000));
[download]

is not guaranteed to produce unique event IDs. For that, you would need to keep track of all the IDs already allocated and re-calculate whenever a new ID duplicates an existing one.

¹The fraction denotes the number of buckets used in the hash divided by the number of buckets allocated.

Hope that helps,

Just a little detail I noticed... I am not sure if this is relevant or maybe even intended, but your event_hasher function has non-obvious side effects:

$_ =~ s/://g;
[download]

This will modify the event data structure because $_ is a writable alias into @event.

I noticed that too and not sure if it is relevant, but I have been stung by something similar in the past. I would re-write the subroutine as:

my $type = event_hasher(\@event);

sub event_hasher {
    my $cur_event = shift;
    my %event_hash;
    for my $item (@$cur_event) {
        $item =~ s/://g;
        my ($key,$value) = split / /, $item;
        $event_hash{$key} = $value;
    }
    return \%event_hash;
}

$queue_changes{$event_id} = $type;
[download]

Update:
As choroba points out below this doesn't solve the problem - in fact it creates it! You need to make a copy of the input - but you are doing that anyway so the aliasing is not the problem. Using choroba's test with your subroutine:

sub event_hasher {
    my @cur_event = @{$_[0]};
    my %event_hash;
    foreach(@cur_event){
        $_ =~ s/://g;
        my @place_holder = split / /, $_;
        $event_hash{$place_holder[0]} = $place_holder[1];
    }
    return %event_hash;
}

my @event = ('a:b c:d');
print "@event\n";
my %type = event_hasher(\@event);
print "@event\n";

# prints:
a:b c:d
a:b c:d
[download]

The problem remains: $item is still an alias to the members of the @event.

#!/usr/bin/perl
use warnings;
use strict;

sub event_hasher {
    my $cur_event = shift;
    my %event_hash;
    for my $item (@$cur_event) {
        $item =~ s/://g;
        my ($key, $value) = split / /, $item;
        $event_hash{$key} = $value;
    }
    return \%event_hash
}

my @event = ('a:b c:d');
print "@event\n";
my $type = event_hasher(\@event);
print "@event\n";
[download]

($q=q:Sq=~/;[c](.)(.)/;chr(-||-|5+lengthSq)`"S|oS2"`map{chr |+ord
}map{substrSq`S_+|`|}3E|-|`7**2-3:)=~y+S|`+$1,++print+eval$q,q,a,
[download]

How did you manage to insert the event into %queue_changes? Perl ought to die with "Invalid value for shared scalar" when you try to assign an unshared reference. Please try the following:

$queue_changes{$event_id} = shared_clone(\%type);
[download]

$event_id = int(rand(25000));
[download]