Thread线程两种方式的优点/缺点

 

extends Thread 方式：

缺点：存在耦合度（因为线程任务run方法里面的业务逻辑 和 线程启动耦合了）

 

缺点：Cat extends Thread {} 后无法在继承其他的类了

优点：没有继承关系 并 简单的单线程，可以使用 extends Thread 方式

 

 

Runnable方式：

优点：第一种方式存在耦合度，第二种方式就解耦了，因为线程任务run方法里面的业务逻辑 和 线程启动分离了）

　　　　　Runnable实现类

　　　　   new Thread().start();

　　　　　new Thread(传递Runnable实现类).start();

　　　　   

优点：Cat implements Runnable {} 后 还可以继承其他的类了

优点：Runnable方式 有着面向对象思想的考虑

 

1.运行多线程要使用Runnable方式；

以下这个案例如果使用  extends Thread 的方式会出现 四个线程对象都持有自己的ticket变量和业务逻辑，给程序开发者带来麻烦

使用Runnable的方式   Runnable实现类Booking给四个Thread去执行的，这样四个线程去 调用 （一个ticket变量和业务逻辑的Runnable实现类）这才是面向对象思想

package android.java.thread07;

/**
 * 售票线程
 */
class Booking implements Runnable {

    /**
     * 模拟票的总算 10张票
     */
    private int ticket = 10;

    @Override
    public void run() {

        while (ticket > 0) {
            if (ticket > 0) {
                System.out.println("名称:" + Thread.currentThread().getName() + "窗口卖出第" + ticket + "张票");
                ticket--;
            }
        }

    }
}

/**
 * 售票案例
 */
public class BookingTest {

    public static void main(String[] args) {

        /**
         * 定义Runnable实现类Booking，此实现类Booking不是线程，此实现类Booking给四个Thread去执行的
         */
        Runnable booking = new Booking();

        // 实例化线程对象
        Thread thread1 = new Thread(booking); // 此实现类Booking给Thread去执行的
        Thread thread2 = new Thread(booking); // 此实现类Booking给Thread去执行的
        Thread thread3 = new Thread(booking); // 此实现类Booking给Thread去执行的
        Thread thread4 = new Thread(booking); // 此实现类Booking给Thread去执行的

        // 开启启动线程
        thread1.start(); // 启动第Thread-0窗口 执行卖票任务
        thread2.start(); // 启动第Thread-1窗口 执行卖票任务
        thread3.start(); // 启动第Thread-2窗口 执行卖票任务
        thread4.start(); // 启动第Thread-3窗口 执行卖票任务


    }

}

 

2.有着继承关系开发的时候，要使用Runnable方式；

1.Dog有着动物的行为call(), 同时还要扩展去执行奔跑的任务，这就是Runnable的好处，所以说Runnable这种方式才是面向对象的思想

2.如果使用 extends Thread 的方式，以下代码写下去还合理么

package android.java.thread08;

/**
 * 定义一个动物类 属于动物父类
 */
abstract class Animal {

    /**
     * 动物叫的行为，抽象的
     */
    public abstract void call();

}

/**
 * 狗类
 */
class Dog extends Animal implements Runnable{

    /**
     * 动物叫的行为，抽象的
     */
    @Override
    public void call() {
        System.out.println("汪汪汪.....");
    }

    /**
     * @see Thread#run()
     */
    @Override
    public void run() {
        System.out.println("狗狗🐶 在自由自在的奔跑");
    }
}

public class Test {

    public static void main(String[] args) {
        // 创建狗对象
        Dog dog = new Dog();

        // 调用狗自己的行为
        dog.call();

        // 启动 Runnable实现类Dog对象的奔跑任务
        new Thread(dog).start();
    }

}

 

3.单任务线程，很明确只执行一个任务，可以使用 extends Thread方式

package android.java.thread08;

class For100 extends Thread {

    @Override
    public void run() {
        super.run();

        for (int i = 0; i < 100; i++) {
            System.out.print(i);
        }
    }
}

public class Test2 {

    public static void main(String[] args) {
        new For100().start();
    }

}

 

 4.在自定义代码中，执行匿名任务，可以使用 extends Thread 方式

public class Test2 {

    public static void main(String[] args) {
        // new For100().start();
        
        new Thread(){
            @Override
            public void run() {
                super.run();
                // 比较耗时的任务
                // ....
            }
        }.start();
    }

}