Interlocked.Increment Method (Int32%)

Parameters

• location
  Type: System.Int32%
  The variable whose value is to be incremented.

Return Value

Type: System.Int32
The incremented value.

Imports System.Threading

Public Class Example

   Private Shared outputBlock As System.Windows.Controls.TextBlock

   Public Shared Sub Demo(ByVal outputBlock As System.Windows.Controls.TextBlock)

      Example.outputBlock = outputBlock
      Dim t As New Thread(AddressOf DemoThreadProc)
      t.Start()

   End Sub

   Private Shared Sub DemoThreadProc()

      ' Start two threads that will create/destroy a large number of CountClass
      ' objects, and block until the thread finish.
      Dim thread1 As New Thread(AddressOf ThreadMethod)
      Dim thread2 As New Thread(AddressOf ThreadMethod)
      thread1.Start()
      thread2.Start()
      thread1.Join()
      thread2.Join()

      ' Have the garbage collector run the finalizer for each
      ' instance of CountClass and wait for it to finish.
      GC.Collect()
      GC.WaitForPendingFinalizers()

      outputBlock.Dispatcher.BeginInvoke(displayHelper, _
          String.Format( _
             "After garbage collection has occurred for all instances of CountClass," & vbLf _
                 & "the instance count should be zero." & vbLf & vbLf _
                 & "UnsafeInstanceCount: {0}" & vbLf & "SafeInstanceCount: {1}", _
                        CountClass.UnsafeInstanceCount, _
                        CountClass.SafeInstanceCount))
   End Sub

   Private Shared Sub ThreadMethod()
      Dim cClass As CountClass

      ' Create 100,000 instances of CountClass.
      For i As Integer = 1 To 100000
         cClass = New CountClass()
      Next i
   End Sub

   ' Helper methods:

   ' In order to update the TextBlock object, which is on the UI thread, you must
   ' make a cross-thread call by using the Dispatcher object that is associated 
   ' with the TextBlock. The DisplayOutput helper method and its delegate, 
   ' displayHelper, are used by the BeginInvoke method of the Dispatcher object
   ' to append text to the TextBlock. 
   '
   Private Shared displayHelper As New Action(Of String)(AddressOf DisplayOutput)
   Private Shared Sub DisplayOutput(ByVal msg As String)
      outputBlock.Text &= msg 
   End Sub

End Class

Public Class CountClass

   Shared unsafeCount As Integer = 0
   Shared safeCount As Integer = 0

   Shared ReadOnly Property UnsafeInstanceCount() As Integer
      Get
         Return unsafeCount
      End Get
   End Property

   Shared ReadOnly Property SafeInstanceCount() As Integer
      Get
         Return safeCount
      End Get
   End Property

   Sub New()
      unsafeCount += 1
      Interlocked.Increment(safeCount)
   End Sub

   Protected Overrides Sub Finalize()
      unsafeCount -= 1
      Interlocked.Decrement(safeCount)
      MyBase.Finalize()
   End Sub

End Class

' This example produces output similar to the following:
'
'After garbage collection has occurred for all instances of CountClass,
'the instance count should be zero.
'
'UnsafeInstanceCount: -305
'SafeInstanceCount: 0

using System;
using System.Threading;

class Example
{
   private static System.Windows.Controls.TextBlock outputBlock;


   public static void Demo(System.Windows.Controls.TextBlock outputBlock)
   {
      Example.outputBlock = outputBlock;
      Thread t = new Thread(DemoThreadProc);
      t.Start();
   }

   private static void DemoThreadProc()
   {
      // Start two threads that will create/destroy a large number of CountClass
      // objects, and block until the thread finish.
      Thread thread1 = new Thread(new ThreadStart(ThreadMethod));
      Thread thread2 = new Thread(new ThreadStart(ThreadMethod));
      thread1.Start();
      thread2.Start();
      thread1.Join();
      thread2.Join();

      // Have the garbage collector run the finalizer for each
      // instance of CountClass and wait for it to finish.
      GC.Collect();
      GC.WaitForPendingFinalizers();

      outputBlock.Dispatcher.BeginInvoke(delegate () {
          outputBlock.Text += String.Format(
             "After garbage collection has occurred for all instances of CountClass,\n" 
                 + "the instance count should be zero.\n\n" 
                 + "UnsafeInstanceCount: {0}\nSafeInstanceCount: {1}\n",
                        CountClass.UnsafeInstanceCount, 
                        CountClass.SafeInstanceCount); 
                                                     });
   }

   static void ThreadMethod()
   {
      CountClass cClass;

      // Create 100,000 instances of CountClass.
      for (int i = 0; i < 100000; i++)
      {
         cClass = new CountClass();
      }
   }
}

class CountClass
{
   static int unsafeInstanceCount = 0;
   static int safeInstanceCount = 0;

   static public int UnsafeInstanceCount
   {
      get { return unsafeInstanceCount; }
   }

   static public int SafeInstanceCount
   {
      get { return safeInstanceCount; }
   }

   public CountClass()
   {
      unsafeInstanceCount++;
      Interlocked.Increment(ref safeInstanceCount);
   }

   ~CountClass()
   {
      unsafeInstanceCount--;
      Interlocked.Decrement(ref safeInstanceCount);
   }
}

/* This example produces output similar to the following:

After garbage collection has occurred for all instances of CountClass,
the instance count should be zero.

UnsafeInstanceCount: -292
SafeInstanceCount: 0
 */