主题：深入理解同步(Threads: deep understanding of synchronizing)

 我只是想在同步时更深入地了解内在机制。 我准备了3个例子。 我有问题涉及他们每个人。 所以这是第一个例子： 
 

public class SyncExamples 
{

    SyncClass sync1, sync2;


    public void execute1()
    {
        sync1 = new SyncClass();
        sync1.process();
    }


    public void execute2()
    {
        sync2 = new SyncClass();
        sync2.process();
    }



    class SyncClass
    {

        public synchronized void process()
        {

        }
    }
}
 
 SyncClass的方法process（）是同步的。 但由于在SyncExamples类中创建了两个不同的SyncClass 对象 ，因此它们可以同时执行，而不是它们。 它们引用不同的对象，因此没有任何同步。 这样对吗？ 
 
 第二个例子： 
 

public class SyncExamples 
{

    SyncClass sync1 = new SyncClass();


    public void execute1()
    {       
        sync1.process();
    }


    public void execute2()
    {       
        sync1.process();
    }




    class SyncClass
    {

        public synchronized void process()
        {

        }
    }
}
 
 所以在这个例子中他们引用了同一个对象。 所以这里我们有一个互斥量。 他们是同步的。 但让我们来看看对我来说最有趣的例子。 
 

public class SyncExamples 
{

    SyncClass sync1 = new SyncClass();
    ReadWriteLock lock = new ReentrantReadWriteLock(); 


    public void execute1()
    {       
        lock.writeLock().lock();
        sync1.process();
        lock.writeLock().unlock();
    }


    public void execute2()
    {       
        execute1();
    }


    public void execute3()
    {       
        sync1.process();
    }


    public void execute4()
    {       
        execute1();
    }


    class SyncClass
    {

        public void process()
        {

        }
    }
}
 
 execute2（）启动execute1（）。 execute1（）锁定sync1.process（）。 因此，execute4（）必须等到execute1（）解锁sync1.process（）。 但是execute3（）怎么样？ 它没有引用execute1（），而是直接调用sync1.process（）而没有任何锁定。 所以execute1（）设置的锁对execute3（）无效？ 是对的吗？ 锁只对那些引用execute1（）的调用有效，因为这个方法定义了一个锁？ 
 
 我在一天后添加了以下示例： 
 

public class SyncExamples 
{

    List list = new ArrayList(); 


    public void processList1()
    {       
        synchronized(list)
        {
        }
    }


    public void processList2()
    {       
        synchronized(list)
        {
        }
    }


    public void execute3()
    {       
        processList1();
    }


    public void execute4()
    {       
        processList2();
    }
}
 
 我想澄清最后一个例子。 现在我有一个我要同步的列表。 方法processList1（）同步list ...方法processList2（）也是如此。 但它们可以同时执行吗？ 同步是否全局锁定列表（我的意思是来自其他方法的所有其他访问）或仅与特定方法结合使用？ 我仍然不明白在这个例子中是否可以同时执行execute3（）和execute4（），因为它们引用了不同的方法。 同步可防止第二次访问其块。 但是有几种方法想要访问列表并且他们使用自己的同步块。 因此，如果processList1（）锁定列表，那么此列表是否会为processList2（）锁定？ 或者这个锁对processList2（）无效，因为它是一个不同的方法？ 

I just want to get a deeper understanding of the inherent mechanisms while synchronizing. I prepared 3 examples. And I have questions that refer to each of them. So here is the first example:
 

public class SyncExamples 
{

    SyncClass sync1, sync2;


    public void execute1()
    {
        sync1 = new SyncClass();
        sync1.process();
    }


    public void execute2()
    {
        sync2 = new SyncClass();
        sync2.process();
    }



    class SyncClass
    {

        public synchronized void process()
        {

        }
    }
}
 
The method process() of SyncClass is synchronized. But due to the fact that in the class SyncExamples two different objects of SyncClass are created they both can be executed concurrently, can't they. They refer to different objects so there isn't any synchronization. Is it right?
 
The second example:
 

public class SyncExamples 
{

    SyncClass sync1 = new SyncClass();


    public void execute1()
    {       
        sync1.process();
    }


    public void execute2()
    {       
        sync1.process();
    }




    class SyncClass
    {

        public synchronized void process()
        {

        }
    }
}
 
So in this example they refer to the very same object. So here we have a mutex. They are synchronized. But let's come to the example most interesting for me. 
 

public class SyncExamples 
{

    SyncClass sync1 = new SyncClass();
    ReadWriteLock lock = new ReentrantReadWriteLock(); 


    public void execute1()
    {       
        lock.writeLock().lock();
        sync1.process();
        lock.writeLock().unlock();
    }


    public void execute2()
    {       
        execute1();
    }


    public void execute3()
    {       
        sync1.process();
    }


    public void execute4()
    {       
        execute1();
    }


    class SyncClass
    {

        public void process()
        {

        }
    }
}
 
execute2() starts execute1(). execute1() locks sync1.process(). For this reason execute4() has to wait until sync1.process() is unlocked by execute1(). But what about execute3()? It does not refer to execute1() but calls directly sync1.process() without any lock. So the lock set by execute1() is not valid for execute3()? Is that right? The lock is only valid for those calls that refer to execute1() as this method defines a lock? 
 
the following example I added one day later:
 

public class SyncExamples 
{

    List list = new ArrayList(); 


    public void processList1()
    {       
        synchronized(list)
        {
        }
    }


    public void processList2()
    {       
        synchronized(list)
        {
        }
    }


    public void execute3()
    {       
        processList1();
    }


    public void execute4()
    {       
        processList2();
    }
}
 
I would like to clarify this one last example. Now I have a list that I want to synchronize. Method processList1() synchronizes the list... method processList2() does it as well. But can they be executed concurrently? Does synchronized lock the list globally (I mean for all other accesses from other methods) or only in conjunction with the specific method? I still don't understand if execute3() and execute4() can be executed concurrently in this example as they refer to different methods. Synchronized prevents a second access to its block. But there are several methods that want to get access to the list and they use their own synchronized blocks. So if processList1() locks the list, is this list then locked for processList2()? Or is this lock not valid for processList2() as it is a different method?

原文：https://stackoverflow.com/questions/20668721