class Res
{
        String sex;
        String name;
}

class InPut implements Runnable
{
        private Res r;
        InPut(Res t)
        {
                this.r=t;
        }
        public void run()
        {
                int x=0;
                while(true)
                {
                        synchronized(InPut.class)//同步代码块锁为对象，静态同步函数锁为类名.class.为什么这里同步代码块用类名.class也可以呢？？？？
                        {
                                if(x==0)
                                {
                                        r.name="mike";
                                        r.sex="man";
                                
                                }
                                else
                                {
                                        r.name="丽丽";
                                        r.sex="女女女女女女";
                                       
                                }
                                x=(x+1)%2;
                        }
                }
        }
}

class OutPut implements Runnable
{
        private Res r;
        OutPut(Res t)
        {
                this.r=t;
        }
        public void run()
        {
                while(true)
                {
                        synchronized(InPut.class)
                        {
                                System.out.println(r.name+"....."+r.sex);
                        }
                }
        }
}

class  Test99
{
        public static void main(String[] args)
        {
                Res r=new Res();
                InPut n=new InPut(r);
                OutPut m=new OutPut(r);
                Thread t1=new Thread(n);
                Thread t2=new Thread(m);
                t1.start();
                t2.start();
        }
}

同步函数的锁要用对象,而类名.class也是一个对象。而你可以先创建一个对象啊，如：Object obj = new Object();,然后在synchronized()中，放入对象obj。

这是有关于线程同步的问题，使用ReentrantLock类的lock()和unlock()方法进行同步，希望能有帮助

只要写个对象就行，静态同步代码快只能为.class。非静态的写个对象就行

只是说静态同步函数的锁只能为类名.class.
并没有说同步函数不能用类名.class.
同步函数的锁要用对象,而类名.class也是一个对象