Webapplikationen sind Multi-Threaded Anwendung. So wird bei Internetanwendungen dann auch zwischen Prozessen und Threads unterschieden. Als Prozess wird
damit im Regelfall die gesamte Applikation bezeichnet, als Thread ein sich in dieser
Applikation befindlicher Ausführungsstrom.
Die elementarste Kernpunkt, die man bei der Eentwicklung von webbasierten Softwaressystenen einhalten müss: Die Prozesse müssen theadsicher sein.
Threadsicherheit bedeutet, dass der Softwarecode gleichzeitig von verschiedenen Programmteilen mehrfach ausgeführt werden kann. Die Schwierigkeit dabei ist, dass die Applikationsdaten nur an einer Stelle und über das bekannte ACID-Prinzip dann natürlich nur exklusiv und durch genau einen thread geändert werden dürfen.
Ein Objekt hat eine schwache Identität, wenn es direkt kann über Anwendungsdomänen-Grenzen zugegriffen haben. Ein Thread, der eine Sperre auf ein Objekt, das eine schwache Identität kann durch einen zweiten Thread in eine andere Anwendung Domäne, die eine Sperre für das gleiche Objekt blockiert werden, hat versucht, zu erwerben.
LOCKING von threadshared Objekten
Natürlich kann man die gesamte Threadverarbeitung mit der lock-Anweisung sperren. Diese ermittelt die Sperre für gegenseitigen Ausschluss eines bestimmten Objekts.
Allerdings darf man diese nicht mit schwachen Objekten sperren:
Imports System
Imports System.Web
Imports System.Web.Caching
Public Class Class1
Private Shared _reportRemovedFromCache As Boolean = False
Shared Sub New()
End Sub
Private Sub New()
End Sub
Public Shared Sub CacheReport()
SyncLock (GetType(Class1))
HttpRuntime.Cache.Add("MyReport", CreateReport(), _
Nothing, Cache.NoAbsoluteExpiration, New TimeSpan(0, 1, 0), _
System.Web.Caching.CacheItemPriority.Default, _
New CacheItemRemovedCallback(AddressOf ReportRemovedCallback))
End SyncLock
End Sub
Private Shared Function CreateReport() As String
Dim myReport As New System.Text.StringBuilder()
myReport.Append("Sales Report")
myReport.Append("2005 Q2 Figures")
myReport.Append("Sales NE Region - $2 million")
myReport.Append("Sales NW Region - $4.5 million")
myReport.Append("Report Generated: " & DateTime.Now.ToString() & "")
myReport.Append("Report Removed From Cache: " _
& _reportRemovedFromCache.ToString())
Return myReport.ToString()
End Function
Public Shared Sub ReportRemovedCallback(ByVal key As String, _
ByVal value As Object, ByVal removedReason _
As CacheItemRemovedReason)
_reportRemovedFromCache = True
CacheReport()
End Sub
End Class
Da Sie nicht unbedingt vorhersagen, welche Sperren aus einer anderen Anwendungsdomäne andauern, und da solche Sperren möglicherweise müssen mobilisiert werden und wäre dann teuer, macht diese Regelung Sinn für mich.
Was sind schwache Objekte?
Ein Objekt hat eine schwache Identität, wenn ein Zugriff darauf über Grenzen von Anwendungsdomänen hinweg möglich ist. Ein Thread, der eine Sperre für ein Objekt zu erhalten versucht, das über eine schwache Identität verfügt, kann durch einen zweiten Thread in einer anderen Anwendungsdomäne blockiert werden, der eine Sperre für das gleiche Objekt besitzt. Die folgenden Typen haben eine schwache Identität und werden durch die Regel gekennzeichnet:
-
System.MarshalByRefObject
-
System.ExecutionEngineException
-
System.OutOfMemoryException
-
System.StackOverflowException
-
System.String
-
System.Reflection.MemberInfo
-
System.Reflection.ParameterInfo
-
System.Threading.Thread
http://stackoverflow.com/questions/1613588/c-lock-and-code-analysis-warning-ca2002
In my application I have a form that starts synchronization process and for number of reasons I want to allow only one synchronization to run at a time. So I've added a static bool field to my form indicating whether sync is in progress and added a lock to set this field to true if it wasn't already set so that first thread could start synchronization but when it's running every other thread that will try to start it will terminate.
My code is something like this:
internal partial class SynchronizationForm : Form
{
private static volatile bool workInProgress;
private void SynchronizationForm_Shown(object sender, EventArgs e)
{
lock (typeof(SynchronizationForm))
{
if (!workInProgress)
{
workInProgress = true;
}
else
{
this.Close();
}
}
}
}
This is working well but when I run Code Analysis on my project I'm getting the following warning message:
CA2002 : Microsoft.Reliability : 'SynchronizationForm.SynchronizationForm_Shown(object, EventArgs)' locks on a reference of type 'Type'. Replace this with a lock against an object with strong-identity.
Can anyone explain to me what's wrong with my code and how can I improve it to make the warning gone. What does it mean that object has a strong-identity?