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();
    }
}