Concurrency support for Ehcache

Last Update:2018-07-26 Source: Internet

Author: User

Tags sleep

Developer on Alibaba Coud: Build your first app with APIs, SDKs, and tutorials on the Alibaba Cloud. Read more ＞

In the case of high concurrency, when using the Ehcache cache, the data we read may be wrong due to concurrent reads and writes, and the data we write may be accidentally overwritten. Fortunately, Ehcache provided us with a read (read)/write (write) lock for the cache element key. The read lock on key can be held by multiple threads at the same time, but until those threads have freed the read lock, the other threads can get the write lock. And at the same time the write lock for this key can only be held by one thread.

When a thread obtains a write lock for a cache key:

1) This thread can take a read lock on the key (that is, the thread can read the value of the key);
2) Other threads cannot obtain the read and write locks of the key (that is, the value of the key cannot be read or written by other threads). Wait until the thread releases the write lock on the key before it can be obtained.

Example:

private static void Testwritelock () {Cache cache = Cachemanager.getcache ("Cache2");
	
	String key = "Key1"; Thread t1 = new Thread (new Runnable () {@Override public void run () {try {Cache.acquirewritelockonkey (key)
				;
					for (int i = 0; i < 5; i++) {Cache.put (New Element (key, i));
					System.out.println ("Thread1 put" + i + "to" + key);
				Thread.Sleep (500);
			}} catch (Exception e) {e.printstacktrace ();
				} finally {Cache.releasewritelockonkey (key);
			System.out.println ("Thread1 end.");
	
	}
		}
	});
		Thread t2 = new Thread (new Runnable () {Boolean canRead = false;
		
		Boolean canWrite = false;
					@Override public void Run () {try {//test one while (true) {Thread.Sleep (300);
						if (Cache.trywritelockonkey (key, 1)) {System.out.println ("Thread2 get write Lock success.");
					CanWrite = true;
					} else {System.out.println ("Thread2 cannot get write lock."); } if (Cache.tryreadlockoNkey (key, 1)) {System.out.println ("Thread2 get read lock success.");
					CanRead = true;
					} else {System.out.println ("thread2 cannot get read lock.");
					} if (CanRead && canWrite) {break;
}}//Test one//test two//Thread.Sleep (1000); for (int i = ten; I < i++) {//Cache.put (New Element (key, i));//System.out.println ("Thread2 put
"+ i +" to "+ key);
}//Test two//test three//Thread.Sleep (1000);
				System.out.println ("Thread2 Get value of" + Key + ":" + cache.get (key). Getobjectvalue ());
			Test three} catch (Exception e) {e.printstacktrace ();
			} finally {System.out.println ("Thread2 end.");
	
	}
		}
	});
	T1.start ();
T2.start (); }

Thread 1 First runs first, it gets the write lock of the element "Key1", and then updates the Key1 value every 0.5 seconds. Run after thread 2.

In the test example, thread 2 will fail every 0.3 seconds to determine if the read and write locks of "Key1" can be obtained. Thread 2 can obtain the read and write locks for "Key1" after thread 1 ends and the write lock "Key1" is released.