返回正在执行的线程:static Thread currentThread();获取当前线程对象
getName();获取线程名称
设置线程名称：setName()或者构造函数。
class Test extends Thread
{
        Test(String name)
        {
                super(name);
        }
        public void run()
        {
                System.out.println(Thread.currentThread().getName());
        }
}
class  ThreadDemo
{
        public static void main(String[] args)
        {
                Test t = new Test();
                t.start();
        }
}
*/
/*
简单的卖票程序
多个窗口卖票

创建线程的第二种方式：实现Runnable接口

步骤：
1，定义类实现Runnable 接口
2，覆盖Runnable接口中的run方法。将线程要运行的代码存放在该run方法中
3，通过Thread类建立线程对象
4，将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数
                为什么要将Runnable接口的子类对象传递给Thread的构造函数
                因为自定义的run方法所属的对象是Runnable接口的子类对象，
                所以要让线程去指定对象的run方法。就必须明确该run方法所属的对象。
5，调用Thread类的start方法开启线程并调用Runnable接口的run方法。

class Ticket extends Thread
{
        private static int tick=100;
        public void run()
        {
                while(true)
                {
                        if(tick>0)
                        {
                                System.out.println(Thread.currentThread().getName()+"sale:"+tick);
                        }
                }
       
        }
}
class TicketDemo
{
        public static void main(String [] args)
        {
                Ticket t1 = new Ticket();
                Ticket t2 = new Ticket();
                Ticket t3 = new Ticket();
                Ticket t4 = new Ticket();

                t1.start();
                t2.start();
                t3.start();
                t4.start();
        }
}

class Ticket implements Runnable//extends Thread
{
        private int tick=100;
        public void run()
        {
                while(true)
                {
                        if(tick>0)
                        {
                                System.out.println(Thread.currentThread().getName()+"sale:"+tick);
                        }
                }
       
        }
}
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();

        }
}
实现方式和继承方式的区别：
    实现好处：避免了单继承的局限性，在定义线程时，建立使用实现方式。
        继承Thread：线程代码存放在Thread子类run方法中，
        实现Runnable：线程代码存放在接口的子类run方法中
*/

System.out.println(Thread.currentThread().getName()+"sale:"+tick);    tick要--   应该是System.out.println(Thread.currentThread().getName()+"sale:"+tick--);
一位大神总结的： 实现方式可以避免单继承的局限性。
通过继承Thread虽然可以完成多线程的建立，但是这种方式有一个局限性。如果一个类已经有了父类，就不可以继承Thread类，因为java单继承的局限性。
可是该类中还有部分代码需要被多个线程同时执行，这时怎么办呢？
只有对该类进行额外的功能扩展，java就提供了一个接口Runnbale接口。
通过该接口就可以避免单继承的局限性，提高了程序的扩展性。
所以定义线程一般都用第二种方式：实现Runnable接口。