[
https://issues.apache.org/jira/browse/OGNL-20?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=13098108#comment-13098108
]
Maurizio Cucchiara commented on OGNL-20:
----------------------------------------
Hi Simone,
to answer your questions...
{quote}
Which complexity has lock/unlock objects? I'm asking because I don't know.
{quote}
I am not sure I understood your question, I guess that lock and unlock are
atomic.
{quote}
Can you point me please to ConcurrentHashMap doc wich explain how locks only
small part of itself and not the whole data?
{quote}
Please, take a look at the
[implementation|http://www.google.it/codesearch#-WpwJU0UKqQ/src/share/classes/java/util/concurrent/ConcurrentHashMap.java&q=ConcurrentHashMap&type=cs&l=242],
you will see that, internally, CHM uses (and hence locks) a segment as a unit
of work (where segment is a small subset of the whole map).
{quote}
except that, for what I can see, the m.getParameterTypes() that worries you, in
the first implementation is invoked only when the key is not found, in the
second is always invoked.
{quote}
you are right, we should clarify how much cost the computation of the final
object value.
Anyway I would not unwrap the {{putIfAbsent}} invocation from the existence
check:
{code}
Map _methodParameterTypesCache = new ConcurrentHashMap();
if ( ( result = (Class[]) _methodParameterTypesCache.get( m )) == null )
{
_methodParameterTypesCache.puIfAbsent( m, result =
m.getParameterTypes() );
}
return result;
{code}
There are many other aspect to take into account: for example CHM doesn't
support null value.
from the javadoc:
{quote}
Like Hashtable but unlike HashMap, this class does not allow null to be used as
a key or value.
{quote}
> Performance - Replace synchronized blocks with ReentrantReadWriteLock
> ---------------------------------------------------------------------
>
> Key: OGNL-20
> URL: https://issues.apache.org/jira/browse/OGNL-20
> Project: OGNL
> Issue Type: Improvement
> Environment: ALL
> Reporter: Greg Lively
>
> I've noticed a lot of synchronized blocks of code in OGNL. For the most part,
> these synchronized blocks are controlling access to HashMaps, etc. I believe
> this could be done far better using ReentrantReadWriteLocks.
> ReentrantReadWriteLock allows unlimited concurrent access, and single threads
> only for writes. Perfect in an environment where the ratio of reads is far
> higher than writes; which is typically the scenario for caching. Plus the
> access control can be tuned for reads and writes; not just a big
> synchronized{} wrapping a bunch of code.
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
