Java多线程Thread基础学习

1. 什么是Java多线程？

Java多线程是指在一个Java程序的执行过程中，有多个线程在同时执行。多线程的出现，可以提高程序的运行效率，提升用户体验。Java实现多线程的方法比较简单，主要依靠一个Thread类来实现。

2. Thread类的基本操作

在Java中，要实现多线程，我们可以创建一个Thread对象，然后重写run()方法，使其在start()方法被调用的时候执行。下面是一个简单的Thread的实现，用于输出数字1~10：

public class MyThread extends Thread {

    public void run() {
        for(int i=1; i<=10; i++) {
            System.out.print(i + " ");
        }
    }

}

public class Main {

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

}

上述代码中，MyThread继承了Thread类，并重写了run()方法。在main()方法中，我们创建了一个MyThread的实例，并通过start()方法启动线程。

3. Runnable接口的基本操作

除了继承Thread类外，还有一种实现多线程的方法：实现Runnable接口，将run()方法作为线程的执行体。这种方法更为常用，因为Java不支持多重继承，且实现Runnable接口可以更方便地共享线程类的实例。

public class MyRunnable implements Runnable {

    public void run() {
        for(int i=1; i<=10; i++) {
            System.out.print(i + " ");
        }
    }

}

public class Main {

    public static void main(String[] args) {
        MyRunnable r = new MyRunnable();
        Thread t = new Thread(r);
        t.start();
    }

}

上述代码中，我们定义了一个MyRunnable类，实现了Runnable接口，并在run()方法中输出数字1~10。在main()方法中，我们创建了一个MyRunnable的实例，并将其作为Thread类的构造函数参数传入，然后启动线程。

4. 线程的状态

线程在执行过程中，会处于不同的状态。Java提供了一些方法获取线程的状态。

• 新建状态（New）：当我们创建一个Thread对象时，线程处于新建状态，还未开始执行。此时可以使用Thread.getState()方法获取状态，返回值为NEW。

• 就绪状态（Runnable）：当线程调用start()方法时，线程进入就绪状态。此时可以使用Thread.getState()方法获取状态，返回值为RUNNABLE。

• 运行状态（Running）：当线程被调度为运行状态，即CPU正在执行该线程时，该线程处于运行状态。此时可以使用Thread.getState()方法获取状态，返回值为RUNNABLE。

• 阻塞状态（Blocked）：线程正在等待锁定的监视器，或正在等待IO资源等，此时线程进入阻塞状态。此时可以使用Thread.getState()方法获取状态，返回值为BLOCKED。

• 等待状态（Waiting）：线程正在等待另一个线程来执行特定操作，此时线程进入等待状态。此时可以使用Thread.getState()方法获取状态，返回值为WAITING。

• 超时等待状态（Timed Waiting）：和等待状态类似，不过超时等待状态有一个超时时间。此时可以使用Thread.getState()方法获取状态，返回值为TIMED_WAITING。

• 结束状态（Terminated）：线程执行完run()方法后，线程进入结束状态。此时可以使用Thread.getState()方法获取状态，返回值为TERMINATED。

5. 总结

以上，我们介绍了Java多线程Thread的基础知识，讲解了Thread类和Runnable接口的基本操作，以及线程的状态。Java中多线程的实现方法还有很多，比如使用线程池，使用Callable，使用Future等，这里不再赘述。

作为一个Java程序员，多线程是必须掌握的知识点，希望本文可以帮助大家更好地理解Java多线程的基础知识。

6. 附加示例

下面是一个示例，演示了两个线程间的通信：

class MySemaphore {

    private boolean signal = false;

    public synchronized void take() {
        this.signal = true;
        this.notify();
    }

    public synchronized void release() throws InterruptedException {
        while (!this.signal) {
            this.wait();
        }
        this.signal = false;
    }

}

class MyThread1 extends Thread {

    private MySemaphore semaphore;

    public MyThread1(MySemaphore semaphore) {
        this.semaphore = semaphore;
    }

    public void run() {
        try {
            System.out.println("Thread 1 - I'm doing some work");
            Thread.sleep(1000);
            this.semaphore.take();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

class MyThread2 extends Thread {

    private MySemaphore semaphore;

    public MyThread2(MySemaphore semaphore) {
        this.semaphore = semaphore;
    }

    public void run() {
        try {
            this.semaphore.release();
            System.out.println("Thread 2 - I'm doing some work");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

public class Main {

    public static void main(String[] args) {

        MySemaphore semaphore = new MySemaphore();
        MyThread1 thread1 = new MyThread1(semaphore);
        MyThread2 thread2 = new MyThread2(semaphore);

        thread1.start();

        try {
            thread2.start();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("All threads done!");

    }

}

在该示例中，我们创建了一个MySemaphore类，用于两个线程间的通信。线程1在执行完一段工作之后，调用MySemaphore的take()方法，线程2在执行完一段工作之前，调用MySemaphore的release()方法。通过MySemaphore通知机制，实现了线程间的同步。