java多线程使用教程_java多线程教学

如何使用多线程

在Java中，创建多线程的方式有两种：一种是继承Thread类，另一种是实现Runnable接口。以下是两种方式的详细介绍和代码示例：

继承Thread类

创建一个多线程，可以继承Thread类并重写它的run()方法。run()方法是线程的主体，当线程启动后，它的run()方法会被调用，并且该方法的执行过程中，线程将处于“运行”状态。

下面是一个简单的继承Thread类的多线程示例：

public class MyThread extends Thread {
    public void run() {
        // 线程的主体，可以在这里编写需要执行的代码
    }
}
1
2
3
4
5

使用这个类创建一个新线程非常简单，只需要实例化该类并调用它的start()方法即可。start()方法会启动线程并调用run()方法。

MyThread myThread = new MyThread();
myThread.start();
1
2

实现Runnable接口

Java中还提供了一种创建多线程的方式，即实现Runnable接口。实现Runnable接口的类需要实现run()方法，该方法的代码将被线程执行。

下面是一个实现Runnable接口的多线程示例：

public class MyRunnable implements Runnable {
    public void run() {
        // 线程的主体，可以在这里编写需要执行的代码
    }
}
1
2
3
4
5

使用这个类创建一个新线程的方式和继承Thread类的方式类似，只需要实例化该类并将它作为参数传递给Thread的构造方法即可。

MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();
1
2
3

线程的生命周期

线程的生命周期指的是线程从创建到销毁的整个过程。Java线程的生命周期可以分为以下5个阶段：

新建状态（New）：当一个线程被创建时，它处于新建状态。此时线程还没有开始执行，也还没有分配到系统资源。

就绪状态（Runnable）：当线程调用start()方法后，线程处于就绪状态。此时线程已经分配到了系统资源，等待系统调度它的时候开始执行。

运行状态（Running）：当线程被系统调度执行时，线程处于运行状态。此时线程正在执行run()方法中的代码。

阻塞状态（Blocked）：线程在执行过程中，可能会因为某些原因需要暂停执行，此时线程处于阻塞状态。比如，线程被sleep()、wait()、join()等方法调用时，线程将进入阻塞状态。

终止状态（Terminated）：线程执行完了run()方法中的代码，或者因为异常而中断了线程，此时线程将进入终止状态。终止状态的线程不再执行任何代码。

下面是一个简单的演示线程生命周期的示例：

public class MyThread extends Thread {
    public void run() {
        System.out.println("线程处于新建状态");
        try {
            Thread.sleep(1000);
            System.out.println("线程处于就绪状态");
            Thread.sleep(1000);
            System.out.println("线程处于运行状态");
            Thread.sleep(1000);
            System.out.println("线程处于阻塞状态");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在这个示例中，线程将会依次进入新建状态、就绪状态、运行状态和阻塞状态。运行这个线程的代码如下：

MyThread myThread = new MyThread();
myThread.start();
1
2

线程同步

在多线程程序中，由于多个线程共享同一份资源，可能会发生冲突问题，比如多个线程同时对同一变量进行写操作，这时就需要使用同步机制来保证线程安全。

Java提供了两种同步机制：synchronized关键字和Lock接口。synchronized关键字是Java中最常用的同步机制，它可以用来修饰方法或代码块。当一个方法或代码块被synchronized修饰后，只有一个线程能够执行该方法或代码块。

下面是一个使用synchronized关键字实现线程同步的示例：

public class MyThread implements Runnable {
    private int count = 0;

    public synchronized void increase() {
        count++;
    }

    public void run() {
        for (int i = 0; i < 100000; i++) {
            increase();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

在这个示例中，increase()方法被synchronized关键字修饰，当一个线程执行increase()方法时，其他线程必须等待，直到当前线程执行完毕才能执行该方法。

下面是一个使用Lock接口实现线程同步的示例：

public class MyThread implements Runnable {
    private int count = 0;
    private Lock lock = new ReentrantLock();

    public void increase() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public void run() {
        for (int i = 0; i < 100000; i++) {
            increase();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

在这个示例中，increase()方法使用了Lock接口来实现线程同步，当一个线程获取了锁后，其他线程必须等待，直到当前线程释放锁才能获取锁执行该方法。

线程间通信

多个线程之间需要进行通信时，可以使用wait()、notify()和notifyAll()方法来实现。

wait()方法会使当前线程进入等待状态，直到其他线程调用notify()或notifyAll()方法唤醒该线程。notify()方法会随机唤醒一个处于等待状态的线程，而notifyAll()方法会唤醒所有处于等待状态的线程。

下面是一个使用wait()和notify()方法实现线程间通信的示例：

public class MyThread implements Runnable {
    private boolean ready = false;

    public synchronized void waitForReady() throws InterruptedException {
        while (!ready) {
            wait();
        }
    }

    public synchronized void setReady() {
        ready = true;
        notify();
    }

    public void run() {
        try {
            waitForReady();
            System.out.println("Thread is ready.");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

在这个示例中，waitForReady()方法会使当前线程进入等待状态，直到其他线程调用setReady()方法将ready标志设置为true并调用notify()方法唤醒该线程。
运行这个线程的代码如下：

MyThread myThread = new MyThread();
new Thread(myThread).start();
Thread.sleep(1000);
myThread.setReady();
1
2
3
4

在这个代码中，启动了一个线程并休眠1秒钟，然后调用setReady()方法将ready标志设置为true并调用notify()方法唤醒该线程。

线程池
线程池是一种重用线程的机制，它可以避免线程的频繁创建和销毁，提高了线程的利用率和效率。

Java提供了Executor框架来实现线程池。Executor框架提供了一些接口，如Executor、ExecutorService、ScheduledExecutorService等，可以用来创建线程池。

下面是一个使用Executor框架实现线程池的示例：

public class MyThread implements Runnable {
    private int taskId;

    public MyThread(int taskId) {
        this.taskId = taskId;
    }

    public void run() {
        System.out.println("Task " + taskId + " is running.");
        }

public static void main(String[] args) {
    ExecutorService executorService = Executors.newFixedThreadPool(3);
    for (int i = 1; i <= 10; i++) {
        executorService.submit(new MyThread(i));
    }
    executorService.shutdown();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

在这个示例中，创建了一个包含3个线程的线程池，然后提交了10个任务给线程池执行。最后调用shutdown()方法关闭线程池。

shutdown()方法的重要性

shutdown() 方法通常在程序或系统的关闭过程中被调用，它的主要目的是进行资源释放和清理工作。在合适的时机调用 shutdown() 方法可以确保程序能够正常地关闭并释放相关资源，同时提供一种优雅的关闭方式。

以下是 shutdown() 方法的几个重要性：

1. 资源释放：shutdown() 方法用于释放程序中使用的资源，如数据库连接、文件句柄、网络连接等。这些资源的释放对于系统的正常运行和资源管理是至关重要的，特别是在长时间运行的程序或服务中。

2. 数据完整性：shutdown() 方法可以用来确保数据的完整性。在程序关闭前，可以通过调用 shutdown() 方法来完成未保存或未提交的数据的保存或提交操作，以避免数据丢失或不一致的情况发生。

3. 状态保存：shutdown() 方法可以用来保存程序的状态。在程序关闭前，可以将当前的状态保存到持久化存储介质（如数据库、文件）中，以便在下次启动时能够恢复到之前的状态。

4. 优雅关闭：通过调用 shutdown() 方法，程序可以进行一系列的清理工作，包括关闭线程、停止任务、发送终止信号等。这样可以确保程序在关闭过程中不会留下无效的线程或任务，并提供一种优雅的关闭方式，避免突然中断程序造成的数据丢失、死锁等问题。

总之，shutdown() 方法的重要性在于保证程序能够正常关闭并释放相关资源，以及提供一种优雅和可控的关闭方式。合理地使用 shutdown() 方法可以提高程序的稳定性和可靠性，确保系统能够平稳地退出或重新启动。