找了条C#面试题，答案怪怪的

Question

47.当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?答：不能，一个对象的一个synchronized方法只能由一个线程访问。
是不是觉得答非所问？问的是：其它线程是否可进入此对象的其它方法?答的是：一个对象的一个synchronized方法只能由一个线程访问。求正确答案。

Answer 1

这是 java 的面试题吧，synchronized 要锁也是锁一个，管不着别的方法

Answer 2

synchronized是锁的意思，还是同步的意思呢？我找到两个意思。是不是说这条题的答案是错的？

Answer 3

意思是一个现成访问对象的synchronized方法之后，其他线程就不能访问对象的其他方法(也就是说不能访问对象)？

Answer 4

看好，“当一个线程进入一个对象的一个synchronized方法后”，是加在方法上，不是什么资源

Answer 5

[img=http://forum.csdn.net/PointForum/ui/scripts/csdn/Plugin/003/onion/14.gif][/im坐看大神决斗

Answer 6

C#也有“Synchronized”方法，如果这里指这个，这题似乎也说的通，只是表述上很有问题
http://msdn.microsoft.com/en-us/library/system.collections.queue.synchronized.aspx

Answer 7

当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法
假如一个 [MethodImpl(Method类型的实例方法有ImplOptions.Synchronized)] 特性
[MethodImpl(MethodImplOptions.Synchronized)]
public void DoSomeWorkSync()
{
   // ......
}在任一时刻只允许一个线程访问同一实例的这个方法，和其他方法有什么关系

Answer 8

Java跟C# 是不是一样d ?

Answer 9

public synchronized void doSomeWorkSync()
{
}Java 是这个样子，功能上应该是一样的

Answer 10

这说的就不是一回事，链接给出是 Queue 这个类有个名字是 Synchronized 的静态方法，返回线程安全的实例，跟方法上加 MethodImplOptions.Synchronized 特性是两码事，一个是方法的名字，一个是方法的特性

Answer 11

我来解释下吧：
不可以，synchronized会锁住整个对象，相当于是lock(this)，这个是它的弊端之一。好处就是编程更简单了，锁的粒度更大些。其他线程想要访问这个对象的非同步方法也是不可能的，因为锁住的是this,也就是整个对象。所以不同的线程要获取的都是同一把锁，形成了互斥关系。这也就是为啥子我们通常喜欢用private static object来作为一个锁对象，使得锁的粒度变小。这样的锁就是针对这个实例里面的一个私有对象，而不是整个实例。

Answer 12

写完回复我就觉得不对了，更正一下：非同步方法不会被锁，因为lock(this)并不会加在每个方法上，只有monitor.enter后该线程才会等待。因为非同步方法不会monitor.enter，所以不会被阻塞。因为并不形成互斥条件。所有应用synchronized特性的方法都会被锁，但是如果采用了其他对象锁比如new 一个 Private 的object的情况因为临界域不同，虽然都是同步方法，但是不会互斥。

Answer 13

貌似而已，写完我就觉得有问题了，只是点击回复点击得太快。上代码，我在代码中形成了2个临界域，记住同临界域才会互斥。所谓的锁哪个对象并不重要，锁一个Type和锁一个private object 并没有本质区别，区别在于Type的可见性高，更容易造成死锁。
    class Program
    {
        static void Main(string[] args)
        {
            var syncTest = new SyncTest();
            Thread t1 = new Thread(syncTest.LongSyncMethod); // critical section 1 ,mutex
            t1.Start();            Thread t2 = new Thread(syncTest.NoSyncMethod);
            t2.Start();            Thread t3 = new Thread(syncTest.LongSyncMethod);// critical section 1 ,mutex
            t3.Start();            Thread t4 = new Thread(syncTest.NoSyncMethod);
            t4.Start();            Thread t5 = new Thread(syncTest.NoSyncMethod);
            t5.Start();            Thread t6 = new Thread(syncTest.SyncMethodUsingPrivateObject);// critical section 2 ,mutex
            t6.Start();            Thread t7 = new Thread(syncTest.SyncMethodUsingPrivateObject);// critical section 2 ,mutex
            t7.Start();
        }
    }
    class SyncTest
    {
        private object _lock = new object();        [MethodImplAttribute(MethodImplOptions.Synchronized)]
        public void LongSyncMethod()
        {
            Console.WriteLine("being asleep");
            Thread.Sleep(10000);
        }
        public void NoSyncMethod()
        {
            Console.WriteLine("do sth");        }
        
        public void SyncMethodUsingPrivateObject()
        {
            lock (_lock)
            {
                Console.WriteLine("another critical section");
                Thread.Sleep(5000);
            }        }
    }

Answer 14

Java里面的说法：如果同步方法被一个线程调用了，那么别的线程也就不能调用该对象的其他同步方法，但是可以调用费同步方法。如果被调用的同步方法是非静态的，那么静态的也可以被别的线程调用。反之亦然。

Answer 15

问题打印错了。进入同步方法后，其他的同步方法的确会被锁，但是不见得所有方法都是同步的吧，问题中那个其他后面大概有一个synchronized漏掉了

Answer 16

楼主是不是记错题目了，是synchronized的对象（加锁的对象），还是对象中的synchronized方法（加锁的方法）啊。要是题目没错的话，答案好像是有点矛盾啊

Answer 17

24 楼 正解，synchronized 是将整个当前对象锁起来，那么第二个线程调用该对象的此同步方法或者其它同步方法时，要等第一个同步方法执行完才能被执行，当然不会影响到其它非同步方法