Java多线程——基础概念

什么是进程和线程

在操作系统中，一个正在运行的程序称为进程（process），进程可以拥有多个相互独立执行流程，称为线程（thread）。一个进程中至少有一个主线程。

为什么需要使用多线程

多线程的主要目的是提高程序的效率，特别是在当程序需要同时执行多个耗时操作时，可以通过多线程将这些操作并发地执行，提高整个程序的执行效率。同时，多线程也能够使得程序具有更好的响应性，因为当一个线程被阻塞时，其他线程还可以继续执行，从而保持程序的运行。

如何实现多线程

Java中实现多线程主要有两种方式：继承Thread类和实现Runnable接口。

继承Thread类

继承Thread类是实现多线程的一种方式，具体步骤如下：

1. 创建Thread子类，并重写run()方法
2. 创建Thread子类的实例，并调用start()方法启动线程

示例代码如下：

public class MyThread extends Thread {
    public void run() {
        System.out.println("This is a new thread, started by extending Thread class.");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
        System.out.println("Main thread has finished.");
    }
}

运行结果：

This is a new thread, started by extending Thread class.
Main thread has finished.

实现Runnable接口

实现Runnable接口也是实现多线程的一种方式，具体步骤如下：

1. 创建实现Runnable接口的类，该类包含一个run()方法
2. 创建该类的实例
3. 创建Thread类的实例，并将刚创建的Runnable实例作为参数传递给Thread的构造方法
4. 调用start()方法启动线程

示例代码如下：

public class MyRunnable implements Runnable {
    public void run() {
        System.out.println("This is a new thread, started by implementing Runnable interface.");
    }
}

public class Main {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
        System.out.println("Main thread has finished.");
    }
}

运行结果：

This is a new thread, started by implementing Runnable interface.
Main thread has finished.

线程的生命周期

在Java中，每个线程都有自己的生命周期。生命周期包括五个状态：

1. 新建状态（New）：线程被创建但还没有启动
2. 就绪状态（Runnable）：线程可以开始执行，等待被调度器调度
3. 运行状态（Running）：线程正在执行任务
4. 阻塞状态（Blocked）：线程被阻塞，等待某些条件的解除，例如等待IO完成、等待锁或等待线程的状态修改等
5. 终止状态（Terminated）：线程执行完任务或出现异常而终止

同步与互斥

多线程中经常会出现对共享资源的竞争，因此需要使用同步和互斥机制来保证对共享资源的正确访问。

Synchronized同步

Synchronized是Java中用来实现同步的关键字，加上Synchronized关键字的代码块，在同一时间只有一个线程可以执行，其他线程需要等待。

示例代码：

public class MyThread extends Thread {
    private static int count = 0;
    public synchronized void run() {
        for (int i = 0; i < 5; i++) {
            count++;
            System.out.println("Thread " + getName() + " gets count = " + count);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();
        thread1.start();
        thread2.start();
    }
}

运行结果：

Thread Thread-0 gets count = 1
Thread Thread-0 gets count = 2
Thread Thread-0 gets count = 3
Thread Thread-0 gets count = 4
Thread Thread-0 gets count = 5
Thread Thread-1 gets count = 6
Thread Thread-1 gets count = 7
Thread Thread-1 gets count = 8
Thread Thread-1 gets count = 9
Thread Thread-1 gets count = 10

Lock互斥

Java中也可以使用Lock接口来实现互斥，Lock接口提供了与Synchronized关键字相同的功能，但它提供了更高级的同步功能。使用Lock需要自己手动加锁和解锁。

示例代码：

public class MyThread extends Thread {
    private static int count = 0;
    private Lock lock = new ReentrantLock();
    public void run() {
        lock.lock();
        try {
            for (int i = 0; i < 5; i++) {
                count++;
                System.out.println("Thread " + getName() + " gets count = " + count);
            }
        } finally {
            lock.unlock();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();
        thread1.start();
        thread2.start();
    }
}

运行结果：

Thread Thread-0 gets count = 1
Thread Thread-0 gets count = 2
Thread Thread-0 gets count = 3
Thread Thread-0 gets count = 4
Thread Thread-0 gets count = 5
Thread Thread-1 gets count = 6
Thread Thread-1 gets count = 7
Thread Thread-1 gets count = 8
Thread Thread-1 gets count = 9
Thread Thread-1 gets count = 10

总结

Java多线程是Java编程领域中比较重要的一块内容，通过本文的讲解，希望读者能够掌握Java多线程的基本概念和实现方式。在实现多线程时要注意同步和互斥，保证程序的正确性和效率。