class Demo implements Runnable
{
        int i;
        Demo(int i){this.i=i;System.out.println(this.i);}
        
        Object c=new Object();
        Object d=new Object();

        public   void run(){
                if(i==1)
                {
                        synchronized(c)
                        {
                                System.out.println("IFA");//try{Thread.sleep(10);}catch(Exception e){}
                                synchronized(d)
                                {
                                        System.out.println("IFB");
                                }
                        }
                }
                else
                {
                        synchronized(d)
                        {
                                System.out.println("ELSEA");
                                synchronized(c)
                                {
                                        System.out.println("ELSEB");
                                }
                        }
                }

        }
}
class Suo
{
        static Object a=new Object();
        static Object b=new Object();
}
class Test  
{
        public static void main(String args[])
        {
               
                Thread t1=new Thread(new Demo(1));
                Thread t2=new Thread(new Demo(2));
               
                t1.start();
                t2.start();
        }
}
输出结果全部打印了，为什么不是死锁
如果把同步代码块对象换成Suo.a和Suo.b就是死锁了，不懂原因

你new了两个Demo 所有有两个c 和两个d 而Suo.a和Suo.b各有一个 如果你要用c和d的话就把它们都定义成static 这样应该没问题了

没有成死锁，原因肯定是用的锁不是同一把。
你在主函数中new出两个线程，并且每个线程中 又各自new了两个Object对象，创建了c和d两个变量去引用这两个对象，很明显这两个线程用的锁根本不一样，等于两个线程各自用各自的锁来开锁。
而用static修饰后，意味着它为该类的所有实例所共享，保证了唯一性。
所以调用Suo.a和Suo.b能成功