Yes it's easy to synchronize objects (at least Storable ones) across threads. RFC677 (yes the one from IETF) tells you how

Sorry, but I completely disagree. What RFC 677 says is that "...the problem of maintaining duplicated databases in an ARPA-like network...." is possible; Not easy!

However, databases store data. In some cases code in the form of stored procedures. There is a world of difference between this and a perl object.

The main one being that stored procedure code only has access to data stored with it in the DB, and constants. Perl object methods can have access to data that exists outside of the object--through references; lvalue refs; lvalue subroutines; coderefs; closures; global variables; and probably others that I haven't thought of.

Perl code (methods) can also be created, modified, deleted and overridden through introspection. Stored procedures cannot.

When you create an object using bless you tie (in the non-Perl sense of the word) the data (attributes) of that instance to a specific vtable of methods that exists within that same thread. When you duplicate this instance through freeze/thaw, the duplicated data is tied to a duplicate vtable.

Whilst applying appropriate sharing (semaphores) and deploying appropriate locks can allow you to coordinate changes to the data across threads. Applying the same coordination to changes to the vtable is fraught with problems if not impossible.

Then there is the problem of class data. Re-creating an instance of a class, does not re-create the class environment for that instance. That is to say, any class data that the instance methods might refer to--eg. Inside-out object hashes--just isn't referenceable nor duplicable.

How would you coordinate an iterator returned by a method that used used closures to track state?

This is a far from exhaustive rebuttal. Far, far, far...from exhaustive. However, perhaps I am missing the solution, so here's my reply:

If it is so easy, show me the code.

Show me the modifications required by this simple code to allow me to share an instance of Chipper such that I can pass a copy of an iterator to two threads and have them concurrently process chars from the string in a coordinated manner?

#! perl -slw
use strict;

package Chipper;
my %pos;

sub TIESCALAR {
    my( $class, $string ) = @_;
    my $self = bless \$string, $class;
    $pos{ $self } = 0;
    return $self;
}

sub FETCH { 
    my( $self ) = @_;
    return $$_[ 0 ];
}

sub STORE { 
    my( $self, $value ) = @_;
    $pos{ $self } = 0;
    return $$self = $value;
}

sub chip {
    my( $self ) = @_;
    $pos{ $self } = 0, return undef if $pos{ $self } >= length $$self;
    return substr $$self, $pos{ $self }++, 1;
}

1;

package main;

my $inst1 = tie my $str1, 'Chipper', 
    'The quick brown fox jumps over the lazy dog';
my $inst2 = tie my $str2, 'Chipper', 
    'Now is the time for all good men to come to the aid of the party'
+;

print "($a$b)" while $a = $inst1->chip and $b = $inst2->chip;
[download]