http://www.google.com/groups?hl=en&lr=&ie=UTF-8&oe=UTF-8&frame=right&th=a1e21baa
ba5303d7&seekm=8b702e36.0403261601.32f47810%40posting.google.com#link2

The poster of this thread got me thinking. He says that "Any time you
can have multiple threads, especially multiple page requests,
accessing the same object, you have to handle any synchronization
issues."

However, any example I see of accessing the Cache (or Application and
Session objects for that matter) typically show this snippet:

  Dim dsProducts As DataSet

  dsProducts = CType(HttpRuntime.Cache.Get("dsProducts"), DataSet)

  If dsProducts Is Nothing Then
     dsProducts = GetProductsFromDatabase()
     
     HttpRuntime.Cache.Insert("dsProducts", dsProducts)
  End If

Now the above example is coded for global.asax but the same would
apply for a page. (Page.Cache instead of HttpRuntime.Cache).

So here is the synchronization issue. Many threads can simultaneously
execute this code snippet (either from the Global class for
HttpRuntime.Cache or from multiple instances of a Page class for
Page.Cache). My understanding is that the Cache object is
multithreaded so we are okay there. However, simultaneous threads can
be reading "dsProducts Is Nothing" and calling "dsProducts =
GetProductsFromDatabase()". The fact that "dsProducts =
GetProductsFromDatabase()" could take a few cycles certainly opens the
door for other threads before the first dsProducts is inserted into
the Cache.

I think the application would still work though. It would just be that
many threads would read from the database and insert into the Cache.
Since the Cache would use a writer lock it would just line up the
.Inserts in sequential access. We would just be doing redundant work.

I think this could be solved by working with the
System.Threading.ReaderWriterLock class and surround the code snippet
above with synchronization to block all reads. This probably
introduces scalability issues from so much blocking since most of the
time the Cache should be full. So that means that doing some redundant
work during the load of the Cache is probably an acceptable tradeoff.

I was wondering if my theories are correct or if I am off my rockers.