線程的兩種實現方式，以及區別

-  讓類成為線程類有兩種方式，實現Runnable接口，以及繼承Thread類（類中實現了Runnable接口，還提供了一些額外的方法）。 

一、Runnable相對優勢：

• java的單繼承，當繼承了Thread類，則不能繼承其他類，而實現Runnable接口可以

• 實現Runnable接口的線程類的多個線程，可以訪問同一變量，而Thread則不能（多窗口買票問題）

原因：兩種方式啟動方式不同：

 

• Runnable線程類是實例化一個對象o之后，通過多次new Thread（o）.start();啟動多個線程，而這幾個線程屬於一個對象，對象的成員變量是同一個。
• Thread線程類啟動多個線程需要 new MyThread().start();每個線程啟動都對應多個對象，他們的成員變量是獨立的。

 測試代碼如下：

（1）實現Runnable:

package com.loan.entity;
 
import lombok.Data;
 
@Data
public class Test2 implements Runnable{
private int ticket=100;
@Override
public void run() {
    // TODO Auto-generated method stub
    while(true){
        if(ticket>0){
            System.out.println(Thread.currentThread().getName()+"...is saling,余票："+ticket--);
        }
    }
}
public static void main(String[] args) {
    Test2 t=new Test2();//只能使用同一個t
    new Thread(t).start();
    new Thread(t).start();
    new Thread(t).start();
    new Thread(t).start();
}
}

 

運行結果：

（2）繼承Thread

package com.loan.entity;
 
public class Test3 extends Thread{
    int ticket=100;
    public void run(){
        while(true){
            if(ticket>0){
                System.out.println(Thread.currentThread().getName()+"...is saling,余票："+ticket--);
            }
        }
    }
    public static void main(String[] args) {
        new Test3().start();
        new Test3().start();
        new Test3().start();
        new Test3().start();
    }
}

很明顯，上面這種方式是錯誤的！

繼承Thread類也可以通過內部類發方式實現。代碼如下：

package com.loan.entity;
 
public class Test3{
    private  int ticket=100;
    class InnerClass extends Thread{
        private Test3 t3;
        InnerClass(Test3 t){
            t3=t;
        }
        public void run(){
            while(true){
                if(ticket>0){
                    ticket--;
                    System.out.println(Thread.currentThread().getName()+"...is saling,余票："+ticket);
                }
            }
        }
    }
    public static void main(String[] args) {
        Test3 test3=new Test3();
        Thread t1=test3.new InnerClass(test3);
        Thread t2=test3.new InnerClass(test3);
        Thread t3=test3.new InnerClass(test3);
        Thread t4=test3.new InnerClass(test3);
        t1.setName("t1");
        t2.setName("t2");
        t3.setName("t3");
        t4.setName("t4");
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        }
}

 

運行結果：

二、Thread優勢

1、使用線程的方法方便一些，例如：獲取線程的Id（Thread.currentThread().getId()）、線程名（Thread.currentThread().getName()）、線程狀態（Thread.currentThread().getState()）等

2、操作同一變量，但是線程調用run方法內容不同時，使用Thread內部類的方式進行，例如生產者、消費者模式

生產者消費者多線程例子：

package com.loan.entity;
 
public class Store {
    private final int MAX_SIZE=2;//倉庫總共可存放貨物
    private int count=0;//當前倉庫貨物
    public synchronized void add() throws InterruptedException{
        while(count>=MAX_SIZE){
            System.out.println("倉庫已滿");
            System.out.println(Thread.currentThread().getName()+"等待中。。。。");
            this.wait();
        }
            count++;
            System.out.println(Thread.currentThread().getName()+"存入倉庫，當前貨物數："+count);
            this.notify();
    }
    public synchronized void remove() throws InterruptedException{
        while(count<=0){
            System.out.println("倉庫空了");
            System.out.println(Thread.currentThread().getName()+"等待中。。。。");
            this.wait();
        }
            count--;
            System.out.println(Thread.currentThread().getName()+"取出貨物，當前貨物數："+count);
            this.notify();
    }
    public static void main(String[] args) {
        Store s=new Store();
        Thread producer1=s.new Producer(s);//成員內部類需通過對象訪問
        Thread producer2=s.new Producer(s);
        Thread consumer1=s.new Consumer(s);
        Thread consumer2=s.new Consumer(s);
        producer1.setName("producer1");//利用Thread中的方法
        producer2.setName("producer2");
        consumer1.setName("consumer1");
        consumer2.setName("consumer2");
        producer1.start();
        producer2.start();
        consumer1.start();
        consumer2.start();
    }
    class Producer extends Thread{
        private Store store;
        Producer(Store s){
            store=s;
        }
        public void run(){
            while(true){
                try {
                    store.add();
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
    class Consumer extends Thread{
        private Store store;
        Consumer(Store s){
            store=s;
        }
        public void run(){
            while(true){
                try {
                    store.remove();
                    Thread.sleep(15000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
}

 

運行結果：