如何解决这个僵局？

Question

我在代码中添加了 cmets 来解释发生死锁的位置。 基本上，有两个线程。每个线程获取一个Manager对象的锁，然后去获取静态资源的锁，这是应用程序中所有Manager对象的映射。两个线程都调用映射上的get()。 Manager 类已覆盖 equals() 方法。 equals() 进一步调用了Manager 类的一些同步方法。因此，映射上的get() 将需要对映射中的每个对象一个一个的对象级锁定，直到键匹配，因为 equals 被覆盖。 我只能更改子类中的代码（Sub1 和Sub2）并避免死锁，因为我无法访问其他类。

编辑：我无权访问 syncMap。 “同步”块中的代码在我调用其 API 的第三方代码中执行。

我可以通过在Manager 上获得锁定finally 来避免这种情况，而不是在尝试阻止之前？！

    public class Parent{
        protected Manager manager;
    }

    public class Global{
        private static final Map syncMap = Collections.synchronizedMap(new HashMap());
        //syncMap contains all the objects of Manager in the application
    }

    class Manager{


        public boolean equals(Object o){

            Manager obj = (Manager)o;
            return obj.getURL().equals(getURL());
        }

        public final synchronized String getURL(){
            return msettings.getDBURL(); //msettings is a global variable
        }


    }


    //Thread-1 is executing someMethod() of this class

    class Sub1 extends Parent{
        Global global;
        //consider manager and Global object are not null
        public void someMethod()
        {
            synchronized(manager){// Thread-1 succesfully takes object level lock on a manager object, say Manager01
                try{
                    global.syncMap.get(manager);
                    // Thread-1 Succesfully takes class level lock on syncMap
                    //  get() calls equals() for each object in syncMap. 
                    //equals() need object lock on each Manager Object in map as it further calls synchronized getURL()
                    // But on one manager Object(Manager02) Thread-2 has already acquired lock and is waiting for lock on syncMap which this thread-1 holds

                }
                finally{
                    manager.releaseConnection();
                }

            }
        }
    }

    //Thread-2 is executing otherMethod() of this class
    class Sub2 extends Parent{ 
        public void otherMethod()
        {
            synchronized(manager){// this takes a lock on manager(Manager02)
                try{
                    global.syncMap.get(manager);
                    // this is blocked as syncMap is aquired by thread-1


                }
                finally{
                    manager.releaseConnection();
                }

            }
        } 
    }

Answer 1

在获取新信息后，除了将所有处理转换为串行样式外，我没有看到其他解决方案。因此，您可以将所有与管理器相关的 API 调用放在某个包装类的一个同步方法中，并将此包装器用作第三方 API 的单个入口点。

class BrutalWrapper {
    public synchronized void doIt(Manager manager)
    {
        try{
            global.syncMap.get(manager);

        }
        finally{
            manager.releaseConnection();
        }
    }
}

class Sub1 extends Parent{
    BrutalWrapper brutal;
    public void someMethod()
    {
        brutal.doIt(manager);
    }
}

class Sub2 extends Parent{
    BrutalWrapper brutal;
    public void someMethod()
    {
        brutal.doIt(manager);
    }
}

Answer 2

首先，您确实应该尝试消除equals 方法中的同步需求。它会带来比解决的更多的麻烦，所以如果重新设计是可能的，那么我认为这是最好的方法。

但是，如果您稍微重构代码并将global.syncMap.get(manager) 移动到synchronization 块之前，则不会产生死锁

public Class Parent{
    protected Manager manager;
}

class Global{
    private static final Map syncMap = Collections.synchronizedMap(new HashMap());
    //syncMap contains all the objects of Manager in the application
}

class Manager{


    public boolean equals(Object o){

        Manager obj = (Manager)o;
        return obj.getURL().equals(getURL());
    }

    public final synchronized String getURL(){
        return msettings.getDBURL(); //msettings is a global variable
    }


}


//Thread-1 is executing someMethod() of this class

class Sub1 extends Parent{
    Global global;
    //consider manager and Global object are not null
    public void someMethod()
    {
         try {
             global.syncMap.get(manager);
             synchronized(manager){

             }
         }
         finally{
             manager.releaseConnection();
         }            
    }
}

//Thread-2 is executing otherMethod() of this class
class Sub2 extends Parent{ 
    public void otherMethod()
    {
         try {
             global.syncMap.get(manager);
             synchronized(manager){

             }
         }
         finally{
             manager.releaseConnection();
         }                        
    } 
}

更新替代同步Global.class，也可以使用实例变量global代替Global.class

更新将同步更改为结束Manager.class，而不是Global.class。

class Sub1 extends Parent
{
    Global global;

    public void someMethod()
    {
        synchronized (Manager.class) { 
            try {
                global.syncMap.get(manager);
            }
            finally {
                manager.releaseConnection();
            }
        }
    }
}


class Sub2 extends Parent
{
    Global global;

    public void otherMethod()
    {
        synchronized (Manager.class) { 
            try {
                global.syncMap.get(manager);
            }
            finally {
                manager.releaseConnection();
            }
        }
    }
}