因此，Thread和Runnable的区别在于，Thread是一个类，而Runnable是一个接口。我们可以通过继承Thread类或者实现Runnable接口来创建一个线程。当我们继承Thread类时，我们需要重写run()方法来定义线程的行为。当我们实现Runnable接口时，我们需要实现run()方法，并将实现了Runnable接口的对象传递给Thread类的构造函数来创建一个线程。

此外，使用实现Runnable接口的方式创建线程更具有灵活性，因为一个类可以实现多个接口，而Java不支持多重继承。另外，使用Runnable还能让我们实现线程的共享，即多个线程共享同一个Runnable实例，从而可以实现多个线程之间传递数据的目的。

总之，无论是继承Thread类还是实现Runnable接口，都可以创建线程，但是实现Runnable更为常用和灵活。因为这种方式能够更好地实现代码的复用和维护，从而提高代码的可读性和可维护性。

相关问题

分别使用继承Thread类和实现runnable接口开 肩线程，其中一个输出奇数，另一个输出偶数

在Java中，创建线程有两种常见的方法：直接继承`Thread`类和实现`Runnable`接口。

1. 继承`Thread`类：

class OddEvenThread extends Thread {
    private boolean isOdd;

    public OddEvenThread(boolean isOdd) {
        this.isOdd = isOdd;
    }

    @Override
    public void run() {
        for (int i = 0; ; i++) {
            if (isOdd) {
                System.out.println(i + " 是奇数");
            } else {
                System.out.println(i + " 是偶数");
            }
            // 没有显式调用sleep()会一直运行，可以根据需求添加睡眠时间
        }
    }

    public static void main(String[] args) {
        OddEvenThread oddThread = new OddEvenThread(true);
        oddThread.start();

        OddEvenThread evenThread = new OddEvenThread(false);
        evenThread.start();
    }
}

在这个例子中，我们创建了两个`OddEvenThread`子类，分别代表奇数和偶数线程。它们各自输出对应的数字类型。

2. 实现`Runnable`接口：

class OddEvenRunnable implements Runnable {
    private boolean isOdd;

    public OddEvenRunnable(boolean isOdd) {
        this.isOdd = isOdd;
    }

    @Override
    public void run() {
        for (int i = 0; ; i++) {
            if (isOdd) {
                System.out.println(i + " 是奇数");
            } else {
                System.out.println(i + " 是偶数");
            }
            // 同样可以添加睡眠时间
        }
    }

    public static void main(String[] args) {
        Thread oddThread = new Thread(new OddEvenRunnable(true));
        oddThread.start();

        Thread evenThread = new Thread(new OddEvenRunnable(false));
        evenThread.start();
    }
}

这里，我们定义了一个`OddEvenRunnable`类，它实现了`Runnable`接口，并在`run()`方法中处理奇偶数输出。然后在`main`方法中通过`Thread`构造函数和`Runnable`实例创建并启动两个线程。

通过继承Thread类或实现Runnable接口可以获得对类中方法的互斥锁定吗

继承`Thread`类或实现`Runnable`接口本身并不能直接获得对类中方法的互斥锁定。在Java中，对于线程安全的操作通常使用`synchronized`关键字或者并发工具类（如`java.util.concurrent.locks`包下的`Lock`和`Semaphore`）来实现互斥访问。

如果你想在多线程环境中保证某个方法的同步性，可以考虑以下方法：

1. **使用`synchronized`**[^4]：在方法前添加`synchronized`关键字，这将使得在同一时间只有一个线程能够执行这个方法。

public synchronized void methodToBeLocked() {
    // 你的业务代码
}

2. **使用`ReentrantLock`**[^5]：如果你需要更精细的控制，可以使用`java.util.concurrent.locks.ReentrantLock`来创建可重入锁。

private final ReentrantLock lock = new ReentrantLock();

public void methodWithLock() {
    lock.lock();
    try {
        // 你的业务代码
    } finally {
        lock.unlock();
    }
}

3. **使用`Semaphore`**[^6]：如果限制的是资源的数量而不是访问权限，可以使用`Semaphore`来控制并发数量。

private final Semaphore semaphore = new Semaphore(1);

public void methodWithSemaphore(int permits) {
    semaphore.acquire(permits);
    try {
        // 你的业务代码
    } finally {
        semaphore.release();
    }
}