class Ticket implements Runnable
{
        private int tic = 100;
        //Object o = new Object();   看这里看这里        public void run()
        {
                while (true)
                {
                        synchronized(new Object())//改成synchronized(o),这两个有什么区别?运行结果是不一样的                        {
                                if (tic > 0)
                                {
                                        try
                                        {
                                                Thread.sleep(10);                                        }
                                        catch (Exception e)
                                        {
                                                //以后再学
                                        }
                                        System.out.println(Thread.currentThread().getName()+" sell ticket "+tic--);
                                }
                        }
                }
        }
}
class TicketDemo
{
        public static void main(String[] args)
        {
                Ticket t = new Ticket();
                Thread t1 = new Thread(t);
                Thread t2 = new Thread(t);
                Thread t3 = new Thread(t);
                Thread t4 = new Thread(t);
                t1.start();
                t2.start();
                t3.start();
                t4.start();
        }
}

new Object() 每个进程进到这里都会创建一个新的object，这时候每个进程使用的同步锁都不是一个，互相之间也不理会对方是不是在使用这段代码，同步失效,Object o = new Object();   o来作锁，这时候o对象在程序运行期间只有一个，是同一个锁

Object o是全局变量，四个线程对应一个；
循环里new Object是局部变量，四个线程每个分别对应一个；
所以运行结果不一样，然后再考虑线程加锁问题

多个线程访问同一个数据，必须对该数据加锁， synchronized(new Object())每个线程只想到这都独自创建一个锁，其实等于没锁，

synchronized(new Object())//改成synchronized(o),这两个有什么区别?运行结果是不一样的   

  匿名对象使用结束就释放了，  在回来的时候就是另一个Object了

崔岩 发表于 2012-3-23 16:51
Ticket t = new Ticket();
你只生成了一个ticket实例，这样如果你用Object o = new Object();   来作锁，这 ...

嗯,有问题太着急了,看了后面的synchronized中对象的含义就想到了...

Ticket t = new Ticket();
你只生成了一个ticket实例，这样如果你用Object o = new Object();   来作锁，这时候o对象在程序运行期间只有一个。这时候所有进程都用的这个O作为锁，互相制约
而当你在（new Object（））以后，每个进程进到这里都会new一个 object，这时候每个进程使用的同步锁都不是一个了，互相之间也不理会对方是不是在使用这段代码，同步就失效了