class Ticket extends Thread //implements Runnable
{
        private  int tick = 100;
        Object obj = new Object();
        public void run()
        {
                while (true)
                {
                        synchronized(this)
                        {
                                if(tick>0)
                                {
                                        try{Thread.sleep(5);}catch (Exception e){}
                                                                               
                                        System.out.println(Thread.currentThread().getName()+"sale:"+tick--);
                                }
                        }
                       
                }
        }
}
class TicketDemo2
{
        public static void main(String[] args)
        {
                Ticket t = new Ticket();
                                Ticket t1 = new Ticket();
                                t.start();
                               t1.start();//这样实现不可以 ，该怎么实现同步呢 ，最好举个例子
                //new Thread(t).start();
                //new Thread(t).start();
                //new Thread(t).start();
                //new Thread(t).start();
                //new Thread(t).start();

               
        }
}

实现Runnable的同步我会，可是继承Thread怎么实现同步呢？

class Ticket extends Thread //implements Runnable
{
        private static int tick = 100;          //首先这里应该改为静态的，以保证两个线程访问的是同一份数据。
        static Object obj = new Object(); //这里也改为静态，下面要用到它。
        public void run()
        {
                while (true)
                {
                        synchronized(obj)　　//其次，这里应使用同一个锁才能保证同步，使用this是不行的，因为两个线程各自有
//自己的对象，它们是两个不同的对象，不是同一个锁。可以使用obj，该对象也必须是静态的，静态是类的所有对象的公共
//数据，非静态则不是，以保证是同一个锁。
                       {
                                if(tick>0)
                                {
                                        try{Thread.sleep(5);}catch (Exception e){}
                                                                                
                                        System.out.println(Thread.currentThread().getName()+"sale:"+tick--);
                                }
                        }
                    if(tick==0)　　//这里应该有循环结束的条件。
                               break;
                }
        }
}
class TicketDemo2
{
        public static void main(String[] args)
        {
                Ticket t = new Ticket();
                Ticket t1 = new Ticket();
                 t.start();
                 t1.start();//这样实现不可以 ，该怎么实现同步呢 ，最好举个例子
           //new Thread(t).start();
                //new Thread(t).start();
                //new Thread(t).start();
                //new Thread(t).start();
                //new Thread(t).start();

               
        }
}

两个对象同步时的this是不同。同步锁对象是同一个代码块才会同步，你生成两个实例。this肯定不同，所以不能同步。可以创建一个静态的成员变量对象。静态成员被共享，而且只有一个，总他来当锁，就可以不用考虑外部生成多少个实例对象的问题，因为静态在累加载时创建，且只有一个。

class Ticket extends Thread //implements Runnable
{
        private static int tick = 100;
        Object obj = new Object();
        public void run()
        {
                while (true)
                {
                        synchronized(obj)//这里可以用obj也可以用该类所对应的文件字节码对象即Ticket.class同步必须保证为同一个锁                        {
                                if(tick>0)
                                {
                                        try{Thread.sleep(5);}catch (Exception e){}
                                                                                
                                        System.out.println(Thread.currentThread().getName()+"sale:"+tick--);
                                }
                        }
                        
                }
        }
}
class TicketDemo2
{
        public static void main(String[] args)
        {
                Ticket t = new Ticket();
                Ticket t1 = new Ticket();
                t.start();
                t1.start();
                               
                                //这样实现不可以 ，该怎么实现同步呢 ，最好举个例子
                //new Thread(t).start();
                //new Thread(t).start();
                //new Thread(t).start();
                //new Thread(t).start();
                //new Thread(t).start();

               
        }
}
同步需满足的两个前提
1，必须有两个或者两个以上线程。
2，必须使用的是同一个锁。

这样同步了，但不是用的一个共享资源，每个线程都使用一个tick。所以你必须把tick静态就搞定了。

孙利川 发表于 2012-4-11 02:16
class Ticket extends Thread //implements Runnable
{
        private static int tick = 100;           ...

非常感谢

郑苑东 发表于 2012-4-11 07:21
两个对象同步时的this是不同。同步锁对象是同一个代码块才会同步，你生成两个实例。this肯定不同，所以不能 ...

谢谢，明白了

常万 发表于 2012-4-11 09:50
class Ticket extends Thread //implements Runnable
{
        private static int tick = 100;

恩 谢谢，明白了