[jira] [Issue Comment Edited] (OGNL-20) Performance - Replace synchronized blocks with ReentrantReadWriteLock

["Maurizio Cucchiara (Issue Comment Edited) (JIRA)" <ji...@apache.org>]

    [ https://issues.apache.org/jira/browse/OGNL-20?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=13128104#comment-13128104 ] 

Maurizio Cucchiara edited comment on OGNL-20 at 10/15/11 8:19 AM:
------------------------------------------------------------------

Hi Daniel,
Thanks for your preciuos feedback.
This is exactly what came to my mind (which, IIUC, is more or less what you suggested before).
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}
                
      was (Author: maurizio.cucchiara):
    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