Java線程實現(xiàn)的兩種方式解析

更新時間：2024年01月10日 10:09:31 作者：愛coding的同學

這篇文章主要介紹了Java線程實現(xiàn)的兩種方式解析,注意在構(gòu)造器中啟動這個線程的話,很容易造成this逃逸的問題,這是要注意的,這是通過直接集成thread來成為線程,同時在這種情況下,你可以通過調(diào)用合適的方法來,需要的朋友可以參考下

Java線程實現(xiàn)的兩種方式解析

1.通過繼承thread，得到一個任務類

/*注意在構(gòu)造器中啟動這個線程的話，很容易造成this逃逸的問題，這是要注意的
* 這是通過直接集成thread來成為線程。同時在這種情況下，你可以通過調(diào)用合適的方法來
* 給thread對象賦予具體的名稱。*/
public class SimpleThread extends  Thread {
    private int countDown=5;
    private static int threadCount=0;
    public SimpleThread() {
        super(Integer.toString(++threadCount));//這是給這個thread賦予名字。
        start();
    }
    public String toString(){
        return "#"+getName()+"("+countDown+"), ";
    }
    public void run() {
        while (true) {
            System.out.print(this);
            if (--countDown == 0) {
                return;
            }
        }
    }
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            new SimpleThread();
        }
    }
}

運行的結(jié)果為：

#1(5),
#2(5),
#3(5),
#3(4),
#3(3),
#3(2),
#4(5),
#2(4),
#5(5),
#5(4),
#1(4),
#5(3),
#5(2),
#2(3),
#2(2),
#2(1),
#4(4),
#4(3),
#4(2),
#4(1),
#3(1),
#5(1),
#1(3),
#1(2),
#1(1),

2.通過實現(xiàn)Runnable接口，來得到一個任務類

//注意，Start()是在構(gòu)造器中調(diào)用的。這個實例相當?shù)暮唵?，因此可能是安全的。但是應該注意?
//在構(gòu)造器重啟動線程可能會變得很有問題。因為另外一個任務可能會在構(gòu)造器結(jié)束以前就開始執(zhí)行了
//這意味著該任務能夠訪問處于不穩(wěn)定狀態(tài)的對象。這是優(yōu)選Executor而不是顯式地創(chuàng)建Thread對象的
//另外一個很重要的原因。
public class SelfManaged implements  Runnable {
    private int countDown=5;
    private Thread t = new Thread(this);
    public SelfManaged() {
        t.start();
    }
    public String toString(){
        return  Thread.currentThread().getName()+"("+countDown+")";
    }
    @Override
    public void run() {
        while (true) {
            System.out.println(this);
            if (--countDown == 0) {
                return;
            }
        }
    }
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            new SelfManaged();
        }
    }
}

最后運行的結(jié)果為：

Thread-0(5)
Thread-2(5)
Thread-1(5)
Thread-1(4)
Thread-2(4)
Thread-2(3)
Thread-2(2)
Thread-2(1)
Thread-0(4)
Thread-0(3)
Thread-0(2)
Thread-0(1)
Thread-3(5)
Thread-1(3)
Thread-3(4)
Thread-4(5)
Thread-4(4)
Thread-4(3)
Thread-4(2)
Thread-4(1)
Thread-1(2)
Thread-1(1)
Thread-3(3)
Thread-3(2)
Thread-3(1)

3.為線程設置優(yōu)先級

但是設置優(yōu)先級只是一個建議。具體是否執(zhí)行的話，還是要看系統(tǒng)內(nèi)部的調(diào)度。

public class SimplePriorities implements  Runnable {
    private int countDown=5;
    private volatile  double d;
    private int priority;
    public SimplePriorities(int priority) {
        this.priority=priority;
    }
    public String toString(){
        return Thread.currentThread()+":"+countDown;
    }
    @Override
    public void run() {
        Thread.currentThread().setPriority(priority);//為這個線程設置優(yōu)先級。
        while (true) {
            for (int i = 0; i < 10000; i++) {
                d += (Math.PI + Math.E)/(double)i;
                if (i / 1000 == 0) {
                    Thread.yield();
                }
            }
            System.out.println(this);
            if (--countDown == 0) {
                return;
            }
        }
    }
    public static void main(String[] args) {
        ExecutorService exec= Executors.newCachedThreadPool();
        for (int i = 0; i < 5; i++) {
            exec.execute(new SimplePriorities(Thread.MAX_PRIORITY));
            exec.execute(new SimplePriorities(Thread.MIN_PRIORITY));
            exec.shutdown();
        }
    }
}

4.繼承thread和實現(xiàn)runnable之間的區(qū)別

1、如是是實現(xiàn)了Runnable接口的話，那么就為實現(xiàn)多繼承提供了方便。因為java中，只允許單繼承。

2、實現(xiàn)runnable接口可以實現(xiàn)資源的共享。

這就是它們之間的最大的區(qū)別。

下面以一個買票的例子來說明它們之間的區(qū)別。

class MyThread extends Thread{  
    private int ticket=10;  
    public void run(){  
        for(int i=0;i<20;i++){  
            if(this.ticket>0){  
                System.out.println("賣票：ticket"+this.ticket--);  
            }  
        }  
    }  
};

下面通過三個線程對象，同時賣票：

package org.demo.dff;  
    public class ThreadTicket {  
    public static void main(String[] args) {  
        MyThread mt1=new MyThread();  
        MyThread mt2=new MyThread();  
        MyThread mt3=new MyThread();  
        mt1.start();//每個線程都各賣了10張，共賣了30張票  
        mt2.start();//但實際只有10張票，每個線程都賣自己的票  
        mt3.start();//沒有達到資源共享  
        }  
    }

 package org.demo.runnable;  
 class MyThread implements Runnable{  
    private int ticket=10;  
    public void run(){  
        for(int i=0;i<20;i++){  
            if(this.ticket>0){  
            System.out.println("賣票：ticket"+this.ticket--);  
                 }  
         }  
    }  
 }  
 package org.demo.runnable;  
 public class RunnableTicket {  
    public static void main(String[] args) {  
        MyThread mt=new MyThread();  
         new Thread(mt).start();//同一個mt，但是在Thread中就不可以，如果用同一  
         new Thread(mt).start();//個實例化對象mt，就會出現(xiàn)異常  
         new Thread(mt).start();  
        }  
    };

到此這篇關(guān)于Java線程實現(xiàn)的兩種方式解析的文章就介紹到這了,更多相關(guān)Java線程實現(xiàn)內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: