public interface Synchronizer
An interface controlling synchronization of configuration instances.
 Each Configuration object derived from
 AbstractConfiguration
 has an associated Synchronizer object. Before an operation on the
 configuration is performed (e.g. a property read or an update), the
 Synchronizer is invoked. Depending on the concrete implementation of
 the Synchronizer used, the configuration can be made thread-safe.
 
 Whether a configuration has to be thread-safe or not is a matter of a
 concrete use case. For instance, an application that just reads some
 configuration settings on startup does need a thread-safe configuration
 implementation. A configuration in contrast which is shared between multiple
 components and updated concurrently should better be thread-safe. In order to
 satisfy both kinds of use cases, the support for thread-safety has been
 extracted out of the configuration implementation and refactored into this
 Synchronizer interface. By assigning different Synchronizer
 implementations to a configuration instance, the instance's support for
 concurrent access can be adapted to the concrete use case.
 
 The methods defined by this interface are similar to a read-write
 lock. The Synchronizer is notified when read or write operations
 start and end. A concrete implementation can then apply a specific policy to
 decide when threads need to block or when access to the configuration for the
 desired operation is granted.
 
| Modifier and Type | Method and Description | 
|---|---|
void | 
beginRead()
Notifies this  
Synchronizer that the current thread is going to
 start a read operation on the managed configuration. | 
void | 
beginWrite()
Notifies this  
Synchronizer that the current thread is going to
 start a write operation on the managed configuration. | 
void | 
endRead()
Notifies this  
Synchronizer that the current thread has finished
 its read operation. | 
void | 
endWrite()
Notifies this  
Synchronizer that the current thread has finished
 its write operation. | 
void beginRead()
Synchronizer that the current thread is going to
 start a read operation on the managed configuration. This call can block
 if a concrete implementation decides that the thread has to wait until a
 specific condition is fulfilled.void endRead()
Synchronizer that the current thread has finished
 its read operation. This may cause other waiting threads to be granted
 access to the managed configuration.void beginWrite()
Synchronizer that the current thread is going to
 start a write operation on the managed configuration. This call may
 block. For instance, a concrete implementation may suspend the thread
 until all read operations currently active are finished,void endWrite()
Synchronizer that the current thread has finished
 its write operation. This may cause other waiting threads to be granted
 access to the managed configuration.Copyright © 2001–2020 The Apache Software Foundation. All rights reserved.