使用Tread和使用runnable有什么区别

在Java中，线程可以通过两种方式来实现：使用Thread类和使用Runnable接口。使用Thread类是直接继承Thread类并重写run()方法，而使用Runnable接口是实现Runnable接口并重写run()方法。

使用Thread类来创建线程是比较简单的，但是这种方式有一些缺点，比如：

- Thread类是final的，因此如果你需要继承其他类，就不能使用Thread类来创建线程；
- 由于Java只支持单继承，因此如果你已经继承了其他类，就不能再继承Thread类了；
- 使用Thread类创建线程会导致代码的耦合度变高，这样就不利于代码的维护和扩展。

使用Runnable接口来创建线程是更加灵活的方式，因为它避免了上述问题。通过实现Runnable接口并重写run()方法，你可以将线程的实现从Thread类中分离出来，并且可以使用更多的设计模式来优化你的代码。

总的来说，使用Thread类和使用Runnable接口都可以实现线程，但是使用Runnable接口是更加灵活、可扩展和可维护的方式。因此，建议在实现多线程时使用Runnable接口。

相关问题

java编写一个应用程序创建两个线程，一个线程打印输出1～1000之间所有的奇数，另外一个线程打印输出1～1000之间所有的偶数，要求两个线程随机休眠一段时间后（1秒内）继续打印输出下一个数。分别使用Runnable接口和Tread类编程实现

使用Runnable接口实现代码如下：

public class PrintNumber implements Runnable {
    private int start;
    private int end;

    public PrintNumber(int start, int end) {
        this.start = start;
        this.end = end;
    }

    public void run() {
        for (int i = start; i <= end; i++) {
            if (Thread.currentThread().getName().equals("Odd") && i % 2 == 1) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
            } else if (Thread.currentThread().getName().equals("Even") && i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
            try {
                Thread.sleep((int) (Math.random() * 1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        PrintNumber oddPrinter = new PrintNumber(1, 1000);
        PrintNumber evenPrinter = new PrintNumber(1, 1000);
        Thread oddThread = new Thread(oddPrinter, "Odd");
        Thread evenThread = new Thread(evenPrinter, "Even");
        oddThread.start();
        evenThread.start();
    }
}

使用Thread类实现代码如下：

public class PrintNumber extends Thread {
    private int start;
    private int end;

    public PrintNumber(String name, int start, int end) {
        super(name);
        this.start = start;
        this.end = end;
    }

    public void run() {
        for (int i = start; i <= end; i++) {
            if (Thread.currentThread().getName().equals("Odd") && i % 2 == 1) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
            } else if (Thread.currentThread().getName().equals("Even") && i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
            try {
                Thread.sleep((int) (Math.random() * 1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        PrintNumber oddThread = new PrintNumber("Odd", 1, 1000);
        PrintNumber evenThread = new PrintNumber("Even", 1, 1000);
        oddThread.start();
        evenThread.start();
    }
}

编写一个应用程序创建两个线程，一个线程打印输出1～1000之间所有的奇数，另外一个线程打印输出1～1000之间所有的偶数，要求两个线程随机休眠一段时间后（1秒内）继续打印输出下一个数。分别使用Runnable接口和Tread类编程实现。

使用Runnable接口实现：

public class PrintNumber implements Runnable {
    private int start;
    private int end;
    private int increment;

    public PrintNumber(int start, int end, int increment) {
        this.start = start;
        this.end = end;
        this.increment = increment;
    }

    @Override
    public void run() {
        for (int i = start; i <= end; i += increment) {
            System.out.println(Thread.currentThread().getName() + ": " + i);
            try {
                Thread.sleep((long) (Math.random() * 1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Thread t1 = new Thread(new PrintNumber(1, 1000, 2), "Even");
        Thread t2 = new Thread(new PrintNumber(2, 1000, 2), "Odd");

        t1.start();
        t2.start();
    }
}

使用Thread类实现：

public class PrintNumber extends Thread {
    private int start;
    private int end;
    private int increment;

    public PrintNumber(String name, int start, int end, int increment) {
        super(name);
        this.start = start;
        this.end = end;
        this.increment = increment;
    }

    @Override
    public void run() {
        for (int i = start; i <= end; i += increment) {
            System.out.println(Thread.currentThread().getName() + ": " + i);
            try {
                Thread.sleep((long) (Math.random() * 1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Thread t1 = new PrintNumber("Even", 1, 1000, 2);
        Thread t2 = new PrintNumber("Odd", 2, 1000, 2);

        t1.start();
        t2.start();
    }
}