method lock

Documentation for method lock assembled from the following types:

class Lock::Async

From Lock::Async

(Lock::Async) method lock

Defined as:

method lock(Lock::Async:D: --> Promise:D)

Acquires the lock, does not wait to acquire the lock. Returns a Promise that will be kept whenever the lock is acquired.

my $l = Lock::Async.new;
$l.lock;

class IO::Handle

From IO::Handle

(IO::Handle) method lock

Defined as:

method lock(IO::Handle:D: Bool:D :$non-blocking = FalseBool:D :$shared = False --> True)

Places an advisory lock on the filehandle. If :$non-blocking is True will fail with X::IO::Lock if lock could not be obtained, otherwise will block until the lock can be placed. If :$shared is True will place a shared (read) lock, otherwise will place an exclusive (write) lock. On success, returns True; fails with X::IO::Lock if lock cannot be placed (e.g. when trying to place a shared lock on a filehandle opened in write mode or trying to place an exclusive lock on a filehandle opened in read mode).

You can use lock again to replace an existing lock with another one. To remove a lock, close the filehandle or use unlock.

# One program writes, the other reads, and thanks to locks either 
# will wait for the other to finish before proceeding to read/write 
 
# Writer 
given "foo".IO.open(:w{
    .lock;
    .spurt: "I ♥ Perl 6!";
    .close# closing the handle unlocks it; we could also use `unlock` method for that 
}
 
# Reader 
given "foo".IO.open {
    .lock: :shared;
    .slurp.say# OUTPUT: «I ♥ Perl 6!␤» 
    .close;
}

class IO::CatHandle

From IO::CatHandle

(IO::CatHandle) method lock

Defined as:

method lock(IO::CatHandle:D: Bool:D :$non-blocking = FalseBool:D :$shared = False --> True)

Same as IO::Handle.lock. Returns Nil if the source handle queue has been exhausted.

Locks only the currently active source handle. The .on-switch Callable can be used to conveniently lock/unlock the handles as they're being processed by the CatHandle.

class Lock

From Lock

(Lock) method lock

Defined as:

method lock(Lock:D:)

Acquires the lock. If it is currently not available, waits for it.

my $l = Lock.new;
$l.lock;

This construct provides a low-level, OS-backed lock (on most platforms, it is a pthreads mutex, for example). The lock is reentrant, meaning that if you acquire it while already holding it then it just bumps a recursion count. Trying to acquire the lock when something else is holding it will really block a thread. If you block a thread pool thread with this construct, it won't be able to work on anything else in the meantime. Further, an await while holding a lock will not function in a non-blocking manner (as a threadpool await normally would in 6.d).

For that reason, it's better to use protect instead of an explicit lock/unlock. That makes sure that the lock is always released. If you forget to unlock then you'll "lose" the lock and nothing will ever be able to acquire it again, probably resulting in the program deadlocking. If you really want to do the unlock yourself, the safest way is in a LEAVE phaser.