javafixes.concurrency

Class Synchronizer<K>

java.lang.Object

javafixes.concurrency.Synchronizer<K>

public class Synchronizer<K>
extends java.lang.Object

A class that allows you to synchronize code on different objects (ids) for whom the .equals() method returns true

Constructor Summary

Constructors

Constructor and Description
Synchronizer()

Method Summary

Modifier and Type	Method and Description
<T> T	synchronizeOn(K key, java.util.concurrent.Callable<T> action) Executes the provided Callable and returning its output value, while making sure that only one action can be run for the provided key
<T> T	synchronizeOn(K key, long time, java.util.concurrent.TimeUnit unit, java.util.concurrent.Callable<T> action) Will attempt to executes the provided Callable and return its output value, while making sure that only one action can be run for the provided key.
void	synchronizeOn(K key, long time, java.util.concurrent.TimeUnit unit, Task action) Will attempt to executes the provided Task while making sure that only one action can be run for the provided key.
void	synchronizeOn(K key, Task action) Executes the provided Task while making sure that only one action can be run for the provided key
void	synchronizeRunnableOn(K key, long time, java.util.concurrent.TimeUnit unit, java.lang.Runnable action) Will attempt to executes the provided Runnable while making sure that only one action can be run for the provided key.
void	synchronizeRunnableOn(K key, java.lang.Runnable action) Executes the provided Runnable while making sure that only one action can be run for the provided key

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Synchronizer

public Synchronizer()

Method Detail

synchronizeOn

public <T> T synchronizeOn(K key,
                           java.util.concurrent.Callable<T> action)
                    throws WrappedException

Executes the provided Callable and returning its output value, while making sure that only one action can be run for the provided key

Parameters:

key - value should be used for synchronization/locking purposes

action - action that should be executed

Returns:

response generated from the provided action parameter

Throws:

WrappedException - any exception thrown from the provided action is wrapped into a WrappedException

synchronizeOn

public <T> T synchronizeOn(K key,
                           long time,
                           java.util.concurrent.TimeUnit unit,
                           java.util.concurrent.Callable<T> action)
                    throws java.util.concurrent.TimeoutException,
                           java.lang.InterruptedException,
                           WrappedException

Will attempt to executes the provided Callable and return its output value, while making sure that only one action can be run for the provided key. In case the lock can't be acquired within given time an TimeoutException is thrown.

Parameters:

key - value should be used for synchronization/locking purposes

time - the maximum time to wait for the lock

unit - the time unit of the time argument

action - action that should be executed

Returns:

response generated from the provided action parameter

Throws:

java.util.concurrent.TimeoutException - if we can't acquire lock within the defined time

java.lang.InterruptedException - if the current thread is interrupted before acquiring the lock

WrappedException - any exception thrown from the provided action is wrapped into a WrappedException

synchronizeRunnableOn

public void synchronizeRunnableOn(K key,
                                  java.lang.Runnable action)
                           throws WrappedException

Executes the provided Runnable while making sure that only one action can be run for the provided key

Parameters:

key - value should be used for synchronization/locking purposes

action - action that should be executed

Throws:

WrappedException - any exception thrown from the provided action is wrapped into a WrappedException

synchronizeRunnableOn

public void synchronizeRunnableOn(K key,
                                  long time,
                                  java.util.concurrent.TimeUnit unit,
                                  java.lang.Runnable action)
                           throws java.util.concurrent.TimeoutException,
                                  java.lang.InterruptedException,
                                  WrappedException

Will attempt to executes the provided Runnable while making sure that only one action can be run for the provided key. In case the lock can't be acquired within given time an TimeoutException is thrown.

Parameters:

key - value should be used for synchronization/locking purposes

time - the maximum time to wait for the lock

unit - the time unit of the time argument

action - action that should be executed

Throws:

java.util.concurrent.TimeoutException - if we can't acquire lock within the defined time

java.lang.InterruptedException - if the current thread is interrupted before acquiring the lock

WrappedException - any exception thrown from the provided action is wrapped into a WrappedException

synchronizeOn

public void synchronizeOn(K key,
                          Task action)
                   throws WrappedException

Executes the provided Task while making sure that only one action can be run for the provided key

Parameters:

key - value should be used for synchronization/locking purposes

action - action that should be executed

Throws:

WrappedException - any exception thrown from the provided action is wrapped into a WrappedException

synchronizeOn

public void synchronizeOn(K key,
                          long time,
                          java.util.concurrent.TimeUnit unit,
                          Task action)
                   throws java.util.concurrent.TimeoutException,
                          java.lang.InterruptedException,
                          WrappedException

Will attempt to executes the provided Task while making sure that only one action can be run for the provided key. In case the lock can't be acquired within given time an TimeoutException is thrown.

Parameters:

key - value should be used for synchronization/locking purposes

time - the maximum time to wait for the lock

unit - the time unit of the time argument

action - action that should be executed

Throws:

java.util.concurrent.TimeoutException - if we can't acquire lock within the defined time

java.lang.InterruptedException - if the current thread is interrupted before acquiring the lock

WrappedException - any exception thrown from the provided action is wrapped into a WrappedException