Monitor.Enter メソッド

.NET Framework クラス ライブラリ リファレンス

Monitor.Enter メソッド

指定したオブジェクトの排他ロックを取得します。

名前空間: System.Threading
アセンブリ: mscorlib (mscorlib.dll 内)
構文

Visual Basic (宣言)

Public Shared Sub Enter
 ( _
    obj As Object _
)

Visual Basic (使用法)

Dim obj As Object

Monitor.Enter(obj)

C#

public static void Enter
 (
    Object obj
)

C++

public:
static void Enter (
    Object^ obj
)

J#

public static void Enter
 (
    Object obj
)

JScript

public static function Enter
 (
    obj : Object
)

パラメータ

obj

モニタ ロックを取得する対象となるオブジェクト。

例外

例外の種類	条件
ArgumentNullException	obj パラメータが null 参照 (Visual Basic では Nothing) です。

解説

Enter を使用して、パラメータとして渡されたオブジェクトで Monitor を取得します。他のスレッドがそのオブジェクトで Enter を実行し、対応する Exit をまだ実行していない場合、現在のスレッドは他のスレッドがオブジェクトを解放するまでブロックします。同じスレッドがブロックを行わずに Enter を複数回呼び出すことは有効ですが、Exit を同じ回数呼び出さないと、そのオブジェクトで待機中の他のスレッドはブロックを解除できません。

値型ではなく、オブジェクト (つまり参照型) をロックするには Monitor を使用します。値型の変数を Enter に渡すと、これはオブジェクトとしてボックス化されます。同じ変数をもう一度 Enter に渡した場合、この変数は別のオブジェクトとしてボックス化され、スレッドはブロックしません。Monitor がプロテクトしていると推定されるコードは、プロテクトされません。また、この変数を Exit に渡すと、さらに別のオブジェクトが作成されます。Exit に渡されたオブジェクトは Enter に渡されたオブジェクトと異なるため、Monitor は SynchronizationLockException をスローします。詳細については、概念に関するトピック「Monitor」を参照してください。

Interrupt は、オブジェクトの Monitor に入るために待機しているスレッドを中断します。ThreadInterruptedException がスローされます。

C# try...finally ブロック (Visual Basic の場合は Try...Finally) を使用して、モニタが確実に解放されるようにするか、C# lock ステートメント (Visual Basic の場合は SyncLock) を使用して、Exit メソッドを try...finally ブロック内にラップします。

使用例

次に示す例は、Enter メソッドを使用する方法です。

Visual Basic

Imports System
Imports System.Threading
Imports System.Collections


Class MonitorSample
    'Define the queue to safe thread access.
    Private m_inputQueue As Queue

    Public Sub New()
        m_inputQueue = New Queue()
    End Sub

    'Add an element to the queue and obtain the monitor lock for the
 queue object.
    Public Sub AddElement(ByVal
 qValue As Object)
        'Lock the queue.
        Monitor.Enter(m_inputQueue)
        'Add an element.
        m_inputQueue.Enqueue(qValue)
        'Unlock the queue.
        Monitor.Exit(m_inputQueue)
    End Sub

    'Try to add an element to the queue.
    'Add the element to the queue only if the queue object is unlocked.
    Public Function AddElementWithoutWait(ByVal
 qValue As Object) As Boolean
        'Determine whether the queue is locked.
        If Not Monitor.TryEnter(m_inputQueue)
 Then
            Return False
        Else
            m_inputQueue.Enqueue(qValue)
            Monitor.Exit(m_inputQueue)
            Return True
        End If
    End Function

    'Try to add an element to the queue. 
    'Add the element to the queue only if during the specified time
 the queue object will be unlocked.
    Public Function WaitToAddElement(ByVal
 qValue As Object, ByVal
 waitTime As Integer) As Boolean
        'Wait while the queue is locked.
        If Not Monitor.TryEnter(m_inputQueue,
 waitTime) Then
            Return False
        Else
            m_inputQueue.Enqueue(qValue)
            Monitor.Exit(m_inputQueue)
            Return True
        End If
    End Function

    'Delete all elements that equal the given object and obtain the
 monitor lock for the queue object.
    Public Sub DeleteElement(ByVal
 qValue As Object)
        'Lock the queue.
        Monitor.Enter(m_inputQueue)
        Dim counter As Integer
 = m_inputQueue.Count
        While (counter > 0)    
            'Check each element.
            Dim elm As Object
 = m_inputQueue.Dequeue()
            If Not elm.Equals(qValue) Then
                m_inputQueue.Enqueue(elm)
            End If
            counter = counter - 1
        End While
        'Unlock the queue.
        Monitor.Exit(m_inputQueue)
    End Sub

    'Print all queue elements.
    Public Sub PrintAllElements()
        'Lock the queue.
        Monitor.Enter(m_inputQueue)
        Dim elmEnum As IEnumerator = m_inputQueue.GetEnumerator()
        While elmEnum.MoveNext()
            'Print the next element.
            Console.WriteLine(elmEnum.Current.ToString())
        End While
        'Unlock the queue.
        Monitor.Exit(m_inputQueue)
    End Sub

    Public Shared Sub Main()
        Dim sample As MonitorSample = New
 MonitorSample()
        Dim i As Integer

        For i = 0 To 29
            sample.AddElement(i)
        Next i
        sample.PrintAllElements()
        sample.DeleteElement(0)
        sample.DeleteElement(10)
        sample.DeleteElement(20)
        sample.PrintAllElements()
    End Sub

End Class

C#

using System;
using System.Collections;
using System.Threading;

namespace MonitorCS2
{
    /// <summary>
    /// Summary description for Class1.
    /// </summary>
    class MonitorSample
    {
        //Define the queue to safe thread access.
        private Queue m_inputQueue;

        public MonitorSample()
        {
            m_inputQueue = new Queue(); 
        }

        //Add an element to the queue and obtain the monitor lock for
 the queue object.
        public void AddElement(object qValue)
        {
            //Lock the queue.
            Monitor.Enter(m_inputQueue);
            //Add element
            m_inputQueue.Enqueue(qValue);
            //Unlock the queue.
            Monitor.Exit(m_inputQueue);
        }

        //Try to add an element to the queue.
        //Add the element to the queue only if the queue object is unlocked.
        public bool AddElementWithoutWait(object
 qValue)
        {
            //Determine whether the queue is locked 
            if(!Monitor.TryEnter(m_inputQueue))
                return false;
            m_inputQueue.Enqueue(qValue);

            Monitor.Exit(m_inputQueue);
            return true;
        }

        //Try to add an element to the queue. 
        //Add the element to the queue only if during the specified
 time the queue object will be unlocked.
        public bool WaitToAddElement(object
 qValue, int waitTime)
        {
            //Wait while the queue is locked.
            if(!Monitor.TryEnter(m_inputQueue,waitTime))
                return false;
            m_inputQueue.Enqueue(qValue);
            Monitor.Exit(m_inputQueue);

            return true;
        }
        
        //Delete all elements that equal the given object and obtain
 the monitor lock for the queue object.
        public void DeleteElement(object qValue)
        {
            //Lock the queue.
            Monitor.Enter(m_inputQueue);
            int counter = m_inputQueue.Count;
            while(counter > 0)
            {    
                //Check each element.
                object elm = m_inputQueue.Dequeue();
                if(!elm.Equals(qValue))
                {
                    m_inputQueue.Enqueue(elm);
                }
                --counter;
            }
            //Unlock the queue.
            Monitor.Exit(m_inputQueue);
        }
        
        //Print all queue elements.
        public void PrintAllElements()
        {
            //Lock the queue.
            Monitor.Enter(m_inputQueue);            
            IEnumerator elmEnum = m_inputQueue.GetEnumerator();
            while(elmEnum.MoveNext())
            {
                //Print the next element.
                Console.WriteLine(elmEnum.Current.ToString());
            }
            //Unlock the queue.
            Monitor.Exit(m_inputQueue);    
        }

        static void Main(string[]
 args)
        {
            MonitorSample sample = new MonitorSample();
            
            for(int i = 0; i < 30; i++)
                sample.AddElement(i);
            sample.PrintAllElements();
            sample.DeleteElement(0);
            sample.DeleteElement(10);
            sample.DeleteElement(20);
            sample.PrintAllElements();

        }
    }
}

C++

using namespace System;
using namespace System::Collections;
using namespace System::Threading;

// Class definition
public ref class MonitorSample
{
public:
   MonitorSample();
   void AddElement( Object^ qValue );
   bool AddElementWithoutWait( Object^ qValue );
   bool WaitToAddElement( Object^ qValue, int
 waitTime );
   void DeleteElement( Object^ qValue );
   void PrintAllElements();

private:
   Queue^ m_inputQueue;
};


//Define the queue to safe thread access.
MonitorSample::MonitorSample()
{
   m_inputQueue = gcnew Queue;
}


//Add an element to the queue and obtain the monitor lock for the queue
 object.
void MonitorSample::AddElement( Object^ qValue )
{
   
   //Lock the queue.
   Monitor::Enter( m_inputQueue );
   
   //Add element
   m_inputQueue->Enqueue( qValue );
   
   //Unlock the queue.
   Monitor::Exit( m_inputQueue );
}


//Try to add an element to the queue.
//Add the element to the queue only if the queue object is unlocked.
bool MonitorSample::AddElementWithoutWait( Object^ qValue )
{
   
   //Determine whether the queue is locked 
   if (  !Monitor::TryEnter( m_inputQueue ) )
      return false;

   m_inputQueue->Enqueue( qValue );
   Monitor::Exit( m_inputQueue );
   return true;
}


//Try to add an element to the queue. 
//Add the element to the queue only if during the specified time the
 queue object will be unlocked.
bool MonitorSample::WaitToAddElement( Object^ qValue, int
 waitTime )
{
   
   //Wait while the queue is locked.
   if (  !Monitor::TryEnter( m_inputQueue, waitTime ) )
      return false;

   m_inputQueue->Enqueue( qValue );
   Monitor::Exit( m_inputQueue );
   return true;
}


//Delete all elements that equal the given object and obtain the monitor
 lock for the queue object.
void MonitorSample::DeleteElement( Object^ qValue )
{
   
   //Lock the queue.
   Monitor::Enter( m_inputQueue );
   int counter = m_inputQueue->Count;
   while ( counter > 0 )
   {
      
      //Check each element.
      Object^ elm = m_inputQueue->Dequeue();
      if (  !elm->Equals( qValue ) )
      {
         m_inputQueue->Enqueue( elm );
      }

      --counter;
   }

   Monitor::Exit( m_inputQueue );
}


//Print all queue elements.
void MonitorSample::PrintAllElements()
{
   
   //Lock the queue.
   Monitor::Enter( m_inputQueue );
   IEnumerator^ elmEnum = m_inputQueue->GetEnumerator();
   while ( elmEnum->MoveNext() )
   {
      
      //Print the next element.
      Console::WriteLine( elmEnum->Current->ToString() );
   }

   Monitor::Exit( m_inputQueue );
}

int main()
{
   MonitorSample^ sample = gcnew MonitorSample;
   for ( int i = 0; i < 30; i++ )
      sample->AddElement( i );
   sample->PrintAllElements();
   sample->DeleteElement( 0 );
   sample->DeleteElement( 10 );
   sample->DeleteElement( 20 );
   sample->PrintAllElements();
}

J#

package MonitorJSL2;

import System.*;
import System.Collections.*;
import System.Threading.*;

/// <summary>
/// Summary description for Class1.
/// </summary>
    
class MonitorSample
{
    //Define the queue to safe thread access.
    private Queue mInputQueue;

    public MonitorSample()
    {
        mInputQueue = new Queue();
    } //MonitorSample

    // Add an element to the queue and obtain the monitor lock for the
 
    // queue object.
    public void AddElement(Object qValue)
    {
        //Lock the queue.
        Monitor.Enter(mInputQueue);

        //Add element
        mInputQueue.Enqueue(qValue);

        //Unlock the queue.
        Monitor.Exit(mInputQueue);
    } //AddElement

    //Try to add an element to the queue.
    //Add the element to the queue only if the queue object is unlocked.
    public boolean AddElementWithoutWait(Object qValue)
    {
        //Determine whether the queue is locked 
        if (!(Monitor.TryEnter(mInputQueue))) {
            return false;
        }
        mInputQueue.Enqueue(qValue);
        Monitor.Exit(mInputQueue);
        return true;
    } //AddElementWithoutWait

    //Try to add an element to the queue. 
    //Add the element to the queue only if during the specified time
 the 
    //queue object will be unlocked.
    public boolean WaitToAddElement(Object qValue, int
 waitTime)
    {
        //Wait while the queue is locked.
        if (!(Monitor.TryEnter(mInputQueue, waitTime))) {
            return false;
        }
        mInputQueue.Enqueue(qValue);
        Monitor.Exit(mInputQueue);

        return true;
    } //WaitToAddElement

    //Delete all elements that equal the given object and obtain the
 
    //monitor lock for the queue object.
    public void DeleteElement(Object qValue)
    {
        //Lock the queue.
        Monitor.Enter(mInputQueue);
        int counter = mInputQueue.get_Count();
        while (counter > 0) {
            //Check each element.
            Object elm = mInputQueue.Dequeue();
            if (!(elm.Equals(qValue))) {
                mInputQueue.Enqueue(elm);
            }
            --counter;
        }

        //Unlock the queue.
        Monitor.Exit(mInputQueue);
    } //DeleteElement

    //Print all queue elements.
    public void PrintAllElements()
    {
        //Lock the queue.
        Monitor.Enter(mInputQueue);
        IEnumerator elmEnum = mInputQueue.GetEnumerator();
        while (elmEnum.MoveNext()) {
            //Print the next element.
            Console.WriteLine(elmEnum.get_Current().ToString());
        }

        //Unlock the queue.
        Monitor.Exit(mInputQueue);
    } //PrintAllElements

    public static void main(String[]
 args)
    {
        MonitorSample sample = new MonitorSample();

        for (int i = 0; i < 30; i++) {
            sample.AddElement((Int32)i);
        }
        sample.PrintAllElements();
        sample.DeleteElement((Int32)0);
        sample.DeleteElement((Int32)10);
        sample.DeleteElement((Int32)20);
        sample.PrintAllElements();
    } //main 
} //MonitorSample

プラットフォーム

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile for Pocket PC, Windows Mobile for Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

開発プラットフォームの中には、.NET Framework によってサポートされていないバージョンがあります。サポートされているバージョンについては、「システム要件」を参照してください。

バージョン情報

.NET Framework
サポート対象 : 2.0、1.1、1.0
.NET Compact Framework
サポート対象 : 2.0、1.0

参照

関連項目
Monitor クラス
Monitor メンバ
System.Threading 名前空間
Thread
その他の技術情報
マネージ スレッド処理
Monitor