[
https://issues.apache.org/jira/browse/OGNL-20?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=13128104#comment-13128104
]
Maurizio Cucchiara commented on OGNL-20:
----------------------------------------
Hi Daniel,
Thanks for your preciuos feedback.
This is exactly what I came to my mind.
I'm going in the following direction:
{code}
public class MethodCacheTest
{
Cache<MethodCacheEntry, Map<String, List<Method>>> cache =
new ConcurrentHashMapCache<MethodCacheEntry,Map<String,
List<Method>>>( new MethodCacheEntryFactory());
@Test
public void testStaticGet( )
throws Exception
{
Map<String, List<Method>> methods = cache.get( new MethodCacheEntry(
Root.class,true ) );
assertNotNull( methods );
assertTrue( methods.containsKey( "getStaticInt" ) );
}
@Test
public void testNonStaticGet( )
throws Exception
{
Map<String, List<Method>> methods = cache.get( new MethodCacheEntry(
Root.class,false) );
assertNotNull( methods );
assertTrue( methods.containsKey( "format" ) );
}
}
{code}
{code}
public class MethodCacheEntry implements CacheEntry
{
private Class<?> targetClass;
private boolean staticMethods;
public MethodCacheEntry( Class<?> targetClass, boolean staticMethods )
{
this.targetClass = targetClass;
this.staticMethods = staticMethods;
}
@Override
public int hashCode( )
{
int result = targetClass.hashCode( );
result = 31 * result + ( staticMethods ? 1 : 0 );
return result;
}
}
{code}
> 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
> Attachments: Bench Results.txt, Caching_Mechanism_Benchmarks.patch
>
>
> 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.
If you think it was sent incorrectly, please contact your JIRA administrators:
https://issues.apache.org/jira/secure/ContactAdministrators!default.jspa
For more information on JIRA, see: http://www.atlassian.com/software/jira
