如果我理解正确的话，你需要这样的东西：

static object lockMethod2 = new object();
static object lockMethod3 = new object();

public static void Method1() 
{
    lock (lockMethod2)
    lock (lockMethod3)
    {
        //Body function
    }
}

public static void Method2() 
{
    lock (lockMethod2)
    {
        //Body function
    }
}

public static void Method3() 
{
    lock (lockMethod3)
    {
        //Body function
    }
}

这允许method3在method2正在运行时执行，反之亦然，而method1必须等待两者。当然，当1正在运行时，method2和3将不会运行。

你的锁的当前实现是完全无用的，因为每个线程将锁定不同的对象。
锁定通常使用只读字段完成，该字段仅初始化一次。
像这样，你可以很容易地锁定多个方法：

public class Class1
{
    private static readonly object _syncRoot = new object();

    public static void Method1() 
    {
        lock (_syncRoot)
        {
            //Body function
        }
    }

    public static void Method2() 
    {
        lock (_syncRoot)
        {
            //Body function
        }
    }

    public static void Method3() 
    {
        lock (_syncRoot)
        {
            //Body function
        }
    }
}

我建议使用ReaderWriterLockSlim（http://msdn.microsoft.com/en-us/library/system.threading.readerwriterlockslim.aspx）
类似于读取操作，方法2和方法3可以并行发生，而方法1（类似于写入操作）将需要等待这些操作完成。这不是常规的读/写并发情况，但逻辑是相似的。

public class Class1
{
    private ReaderWriterLockSlim methodLock = new ReaderWriterLockSlim();
    public static void Method1() 
    {
        methodLock.EnterWriteLock();
        try
        {
            //Body function
        }
        finally
        {
            methodLock.ExitWriteLock();
        }
    }

    public static void Method2() 
    {
         methodLock.EnterReadLock();
        try
        {
            //Body function
        }
        finally
        {
            methodLock.ExitReadLock();
        }
    }

    public static void Method3() 
    {
         methodLock.EnterReadLock();
        try
        {
            //Body function
        }
        finally
        {
            methodLock.ExitReadLock();
        }
    }
}

如果你是多线程的，那么lock必须对所有线程都是可访问的。因此，在这种情况下，您的锁需要是静态的，以便静态方法可以看到它。
您当前的设置将为每个线程创建一个新的锁对象。因此，现在提供同步。

如果我正确理解了你的要求，那么你可以这样做：

public static object lockobj = new object();
public static void Method1() 
{
    
    lock (lockobj)
    {
        // Body of Method1

        // Call Method2
        Method2();

        // Call Method3
        Method3();

        // More code in Method1
    }
}

public static void Method2() 
{  
    //Body function   
}

public static void Method3() 
{ 
    //Body function    
}