I&#39;m trying to understand what makes the lock in concurrency so important if one can use `synchronized (this)`. In the dummy code below, I can do either:

 1. synchronized the entire method or synchronize the vulnerable area (`synchronized(this){...}`)
 2. OR lock the vulnerable code area with a ReentrantLock.

Code:

        private final ReentrantLock lock = new ReentrantLock(); 
        private static List&lt;Integer&gt; ints;
	
        public Integer getResult(String name) { 
            .
            .
            .
            lock.lock();
            try {
                if (ints.size()==3) {
                    ints=null;
                    return -9;
                }	
			
                for (int x=0; x&lt;ints.size(); x++) {
                    System.out.println(&quot;[&quot;+name+&quot;] &quot;+x+&quot;/&quot;+ints.size()+&quot;. values &gt;&gt;&gt;&gt;&quot;+ints.get(x));
                }
			
            } finally {
                lock.unlock();
            } 
            return random;
    }

 

All Synchronize Solutions on Gang of Coders

Total of 1 Synchronize Solutions

Why use a ReentrantLock if one can use synchronized(this)?