Java中Thread的常用方法

/*
 *Thread常用方法
 *1.start():启动当前的线程，调用当前线程的run()
 *2.run():通常需要重写Thread类中的此方法，将创建要执行的操作声明在此方法中
 *3.currentThread():静态方法，返回代码执行的线程
 *4.getName():获取当前线程的名字
 *5.setName():设置当前线程的名字
 *6.yield():释放当前CPU的执行
 *7.join():在线程a中调用线程b的join()方法,此时线程a进入阻塞状态
 *8.stop():已过时的方法，当执行此方法是，强制结束当前进程
 *9.sleep(long millitime):让当前进程睡眠指定的毫秒数，在指定时间内，线程是阻塞状态
 *10.isAlive():判断进程是否存活
 */
class HelloThread extends Thread
{
    public void run()
    {
        for(int i=1;i<20;i++)
        {
            if((i&1)==0)
            {/*
            sleep()，是静态的可以直接通过类调用，会抛异常
            HelloThread是继承在Thread里的，在Thread里run()没有抛异常（子类重写方法抛出的异常<=父类被重写异常抛出的方法），
            所以此处不可以throws，只能用try-catch
            */
                try {
                    sleep(1000);//阻塞1000ms，即1s
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                //在1s阻塞后，等CPU分配资源再运行主程序
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            if(i%10==0)
            {
                this.yield();
            }
        }
    }
    /*在源码中可以看到 Thread有对于名字命名的构造器
     * public Thread(String name) {
     *    init(null, null, name, 0);
     * }
     * 所以子类继承父类的构造器就行
     */
    /*
    public HelloThread(String name)
    {
        super(name);
    }
    */
}
public class test{
    public static void main(String[] args) {
        //给线程命名方法1 调用setName()
        HelloThread h1=new HelloThread();
        HelloThread h2=new HelloThread();
        h1.setName("*1*");
        h2.setName("*2*");
        h1.start();
        h2.start();
        //给线程命名方法2 建立类对象，调用构造器
        /*
         *HelloThread h2=new HelloTHread("*2*"); 
         */
        //给主线程命名
        Thread.currentThread().setName("主线程");
        for(int i=0;i<20;i++)
        {
            if((i&1)==1)
            {
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            if(i==10)
            {
                try {//主线程中调用h1的join()方法，此时主线程进入阻塞状态
                    h1.join();//join是Thread中的方法，不是该类中的方法，只能通过继承Thread类的子类对象调用
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
}

通过上述学习的方法，我们来完成一个具体的例子。 

创建三个窗口共卖100张票。（暂时忽略线程不安全即出现重票现象）

1.通过类继承Thread实现

//创建三个窗口共卖100张票

class Window extends Thread
{
    private static int ticket=100;
    public void run()
    {
        while(true)
        {
            if(ticket>0)
            {
                System.out.println(getName()+":卖票，票号为："+ticket);
                ticket--;
            }
            else
                break;
        }
    }
}
public class test
{
    public static void main(String[] args)
    {
        Window t1=new Window();
        Window t2=new Window();
        Window t3=new Window();
        t1.setName("*1*");
        t2.setName("*2*");
        t3.setName("*3*");
        t1.start();
        t2.start();
        t3.start();
    }
}

2.通过类调用接口实现

//创建三个窗口共卖100张票
class Window implements Runnable
{
    private int ticket=100;
    public void run()
    {
        while(true)
        {
            if(ticket>0)
            {
                System.out.println(Thread.currentThread().getName()+"卖票，票号为："+ticket);
                ticket--;
            }
            else
                break;
        }
    }
}
public class test{
    public static void main(String[] args) {
        Window w=new Window();//因为只造了一个Window类对象，3个线程公用一个进程，所以不用把ticket声明为静态的
        Thread t1=new Thread(w);
        Thread t2=new Thread(w);
        Thread t3=new Thread(w);
        t1.setName("1");
        t1.setName("2");
        t1.setName("3");
        t1.start();
        t2.start();
        t3.start();
    }
}