Public Shared Function Increment ( _
    ByRef location As Integer _
) As Integer

Dim location As Integer
Dim returnValue As Integer

returnValue = Interlocked.Increment(location)

public static int Increment (
    ref int location
)

public:
static int Increment (
    int% location
)

public static int Increment (
    /** @ref */ int location
)

JScript ne prend pas en charge le passage d'arguments de type valeur par référence.

Imports Microsoft.VisualBasic
Imports System
Imports System.Threading

Public Class Test

    <MTAThread> _
    Shared Sub Main()
        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()

        Console.WriteLine("UnsafeInstanceCount: {0}" & _
            vbCrLf & "SafeCountInstances: {1}", _
            CountClass.UnsafeInstanceCount.ToString(), _
            CountClass.SafeInstanceCount.ToString())
   End Sub

   Shared Sub ThreadMethod()
        Dim cClass As CountClass 

        ' Create 100,000 instances of CountClass.
        For i As Integer = 1 To 100000
            cClass = New CountClass()
            cClass = Nothing
            i += 1
        Next i
   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

using System;
using System.Threading;

class Test
{
    static void Main()
    {
        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();

        Console.WriteLine("UnsafeInstanceCount: {0}" +
            "\nSafeCountInstances: {1}",
            CountClass.UnsafeInstanceCount.ToString(),
            CountClass.SafeInstanceCount.ToString());
    }

    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);
    }
}

using namespace System;
using namespace System::Threading;
ref class CountClass
{
private:
   static int unsafeInstanceCount;
   static int safeInstanceCount;

public:

   static property int UnsafeInstanceCount 
   {
      int get()
      {
         return unsafeInstanceCount;
      }

   }

   static property int SafeInstanceCount 
   {
      int get()
      {
         return safeInstanceCount;
      }

   }
   CountClass()
   {
      unsafeInstanceCount++;
      Interlocked::Increment( safeInstanceCount );
   }

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

};

ref class Test
{
public:
   static void ThreadMethod()
   {
      CountClass^ cClass;
      
      // Create 100,000 instances of CountClass.
      for ( int i = 0; i < 100000; i++ )
      {
         cClass = gcnew CountClass;

      }
   }

};

int main()
{
   Thread^ thread1 = gcnew Thread( gcnew ThreadStart( &Test::ThreadMethod ) );
   Thread^ thread2 = gcnew Thread( gcnew ThreadStart( &Test::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();
   Console::WriteLine( "UnsafeInstanceCount: {0}"
   "\nSafeCountInstances: {1}", CountClass::UnsafeInstanceCount.ToString(), CountClass::SafeInstanceCount.ToString() );
}

import System.*;
import System.Threading.*;
import System.Threading.Thread;

class Test
{
    public static void main(String[] args)
    {
        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();
        Console.WriteLine("UnsafeInstanceCount: {0}" + 
            "\nSafeCountInstances: {1}", 
            String.valueOf(CountClass.get_UnsafeInstanceCount()), 
            String.valueOf(CountClass.get_SafeInstanceCount()));
    } //main

    static void ThreadMethod()
    {
        CountClass cClass;

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

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

    /** @property
     */
    public static int get_UnsafeInstanceCount()
    {
        return unsafeInstanceCount;
    } //get_UnsafeInstanceCount

    /** @property
     */
    public static int get_SafeInstanceCount()
    {
        return safeInstanceCount;
    } //get_SafeInstanceCount

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

    public void finalize()
    {
        try {
            unsafeInstanceCount--;
            Interlocked.Decrement(safeInstanceCount);
            super.finalize();
        }
        catch (Throwable th) { 
        }
    } //finalize
}  //CountClass