class Ticket implements Runnable
{
        private static  int tick = 100;
        //Object obj = new Object();
        boolean flag = true;
        public  void run()
        {
                if(flag)
                {
                        while(true)
                        {
                                synchronized(Ticket.class)
                                {
                                        if(tick>0)
                                        {
                                                try{Thread.sleep(10);}catch(Exception e){}
                                                System.out.println(Thread.currentThread().getName()+"....code : "+ tick--);
                                        }
                                }
                        }
                }
                else
                        while(true)
                                show();
        }
        public static synchronized void show()
        {
                if(tick>0)
                {
                        try{Thread.sleep(10);}catch(Exception e){}
                        System.out.println(Thread.currentThread().getName()+"....show.... : "+ tick--);
                }
        }
}


class  StaticMethodDemo
{
        public static void main(String[] args)
        {

                Ticket t = new Ticket();

                Thread t1 = new Thread(t);
                Thread t2 = new Thread(t);
                t1.start();
                try{Thread.sleep(10);}catch(Exception e){}
                t.flag = false;
                t2.start();


        }
}
如果同步函数被静态修饰后，使用的锁是什么呢？

就因为static标记后，对象只有类的class文件，synchronized(Ticket.class)后只能跟对象,所以使用的锁就必须是class？

是只能用类的class对象，因为show的锁是这个，因为必须同锁，所以上面的也必须是类.class

路过路过