一文带你学习Java中的线程

什么是线程

线程是操作系统能够进行运算调度的最小单位。也就是说，线程是进程中的一个实体，是被系统独立调度和分配CPU时间的基本单位，是比进程更小的能独立运行的基本单位。

在Java中，线程是一个单独的执行路径，每个线程都有自己的栈和程序计数器。JVM运行线程调度，每个线程的执行顺序和时间是由操作系统决定。

如何创建线程

在Java中，有三种方法可以创建线程。

1. 继承Thread类并覆盖run()方法。
   java
public class MyThread extends Thread {
@Override
public void run() {
// 线程执行的代码
}
}
2. 实现Runnable接口并实现run()方法。
   java
public class MyRunnable implements Runnable {
@Override
public void run() {
// 线程执行的代码
}
}
3. 使用匿名内部类创建线程。
   java
Thread myThread = new Thread(new Runnable() {
@Override
public void run() {
// 线程执行的代码
}
});

如何启动线程

在创建好线程后，需要使用start()方法来启动线程。start()方法会让线程进入可运行状态，等待JVM的调度。

Thread myThread = new MyThread();
myThread.start();

线程的状态

在Java中，线程可以有以下几种状态：

• NEW：刚创建新线程，还未执行start()方法。
• RUNNABLE：线程正在运行或等待CPU时间片，可以进入运行状态。
• BLOCKED：线程阻塞于锁定的资源，等待释放锁。
• WAITING：线程等待其他线程做出特定动作（无超时限制）。
• TIMED_WAITING：线程等待其他线程做出特定动作（有超时限制）。
• TERMINATED：线程已完成执行。

线程的生命周期

线程的生命周期包括以下几个阶段：

1. NEW：新建状态。
2. RUNNABLE：就绪状态。
3. RUNNING：运行状态。
4. BLOCKED：阻塞状态。
5. TERMINATED：结束状态。

线程的同步

在多线程的情况下，同步是非常重要的。在Java中，可以使用synchronized关键字和lock机制实现线程的同步。

1. 使用synchronized关键字

synchronized关键字可以用来保证多个线程之间的同步，它可以用来修饰方法和代码块。

java
public synchronized void method() {
// 线程同步代码
}

1. 使用Lock机制

Lock机制是从JDK5开始引入的，它提供了比synchronized更强大的线程同步机制。使用Lock机制，需要先获取锁再执行线程同步代码。

java
Lock lock = new ReentrantLock();
lock.lock();
try {
// 线程同步代码
} finally {
lock.unlock();
}

线程的常用方法

在Java中，线程有一些常用的方法。

1. sleep()：使当前线程休眠指定的时间。
   java
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
2. yield()：让出CPU使用权，但不阻塞线程。
   java
Thread.yield();
3. join()：等待其他线程执行完毕。
   java
try {
myThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}

示例1：使用线程打印1-10数字

public class PrintThread extends Thread {
    private int start;
    private int end;
    public PrintThread(int start, int end) {
        this.start = start;
        this.end = end;
    }
    @Override
    public void run() {
        for (int i = start; i <= end; i++) {
            System.out.println(i);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        PrintThread thread1 = new PrintThread(1, 5);
        PrintThread thread2 = new PrintThread(6, 10);
        thread1.start();
        thread2.start();
    }
}

示例2：使用线程计算1-100的总和

public class SumThread extends Thread {
    private int start;
    private int end;
    private int sum;
    public SumThread(int start, int end) {
        this.start = start;
        this.end = end;
        this.sum = 0;
    }
    @Override
    public void run() {
        for (int i = start; i <= end; i++) {
            sum += i;
        }
    }
    public int getSum() {
        return sum;
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        SumThread thread1 = new SumThread(1, 50);
        SumThread thread2 = new SumThread(51, 100);
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        int total = thread1.getSum() + thread2.getSum();
        System.out.println("1-100的总和为：" + total);
    }
}