Java 线程

Java线程是Java语言中的一个重要特性，它允许程序在同一个进程中执行多个并发任务。Java线程为Java应用程序提供了更好的性能和响应能力。本篇博客将介绍Java线程的基本概念、创建和启动线程的方法、线程状态、线程同步和线程池等内容。

基本概念

线程是Java中最基本的并发编程单元，它是程序中一个独立的执行流。Java线程可以同时执行多个任务，每个任务都运行在独立的线程中。Java线程的实现依赖于Java虚拟机（JVM），它提供了线程的创建、管理、同步和通信等功能。

Java线程有以下几个基本概念：

• 线程对象：Java线程是通过创建线程对象来实现的。线程对象是Thread类的一个实例，它封装了线程的状态和行为。
• 线程状态：线程可以处于不同的状态，比如新建、运行、等待、阻塞、终止等状态。
• 线程同步：线程同步是指多个线程协同工作，共同完成任务。线程同步可以通过锁、信号量、条件变量等机制来实现。
• 线程通信：线程通信是指多个线程之间的数据交换和互相协作。线程通信可以通过共享内存、消息队列、管道等机制来实现。

创建和启动线程

Java中创建线程的方法有两种，一种是实现Runnable接口，另一种是继承Thread类。下面分别介绍这两种方法。

实现Runnable接口

实现Runnable接口是Java中创建线程的推荐方法。实现Runnable接口可以将线程的任务逻辑与线程对象分离，使得代码更加清晰和可维护。实现Runnable接口需要实现run()方法，在run()方法中编写线程的任务逻辑。

下面是一个实现Runnable接口的例子：

class MyRunnable implements Runnable {
  public void run() {
    System.out.println("Hello from MyRunnable!");
  }
}

public class Main {
  public static void main(String[] args) {
    Thread thread = new Thread(new MyRunnable());
    thread.start();
  }
}

在这个例子中，我们定义了一个MyRunnable类实现了Runnable接口，并在run()方法中编写了线程的任务逻辑。在主线程中，我们创建了一个Thread对象并将MyRunnable对象作为参数传入，然后调用start()方法来启动线程。

继承Thread类

继承Thread类是Java中创建线程的另一种方法。继承Thread类可以直接重写run()方法，在run()方法中编写线程的任务逻辑。

下面是一个继承Thread类的例子：

class MyThread extends Thread {
  public void run() {
    System.out.println("Hello from MyThread!");
  }
}

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

在这个例子中，我们定义了一个MyThread类继承了Thread类，并重写了run()方法，在run()方法中编写了线程的任务逻辑。在主线程中，我们创建了一个MyThread对象并调用start()方法来启动线程。

线程状态

Java线程可以处于不同的状态，状态由Thread.State枚举类型表示。Thread.State枚举类型定义了以下几个状态：

• NEW：线程对象已创建，但尚未启动。
• RUNNABLE：线程正在运行或准备运行。
• BLOCKED：线程正在等待获取一个锁以进入同步代码块。
• WAITING：线程正在等待另一个线程执行特定的操作。
  -TIMED_WAITING：线程正在等待另一个线程执行特定的操作，但等待时间有限。
• TERMINATED：线程已经执行完毕。

Java线程状态的转换由JVM自动管理，可以通过Thread对象的getState()方法来获取线程的状态。

下面是一个展示线程状态的例子：

public class Main {
  public static void main(String[] args) throws InterruptedException {
    Thread thread = new Thread(() -> {
      System.out.println("Hello from thread!");
      try {
        Thread.sleep(1000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    });
    System.out.println("Thread state: " + thread.getState()); // NEW
    thread.start();
    System.out.println("Thread state: " + thread.getState()); // RUNNABLE
    Thread.sleep(500);
    System.out.println("Thread state: " + thread.getState()); // TIMED_WAITING
    Thread.sleep(1000);
    System.out.println("Thread state: " + thread.getState()); // TERMINATED
  }
}

在这个例子中，我们创建了一个新的线程对象，并在run()方法中打印一条消息并等待1秒钟。在主线程中，我们先通过getState()方法获取线程的状态，此时线程的状态为NEW。然后我们调用start()方法启动线程，并再次通过getState()方法获取线程的状态，此时线程的状态为RUNNABLE。接着我们让主线程等待500毫秒，然后再次通过getState()方法获取线程的状态，此时线程的状态为TIMED_WAITING，因为线程正在等待1秒钟。最后我们让主线程等待1秒钟，然后再次通过getState()方法获取线程的状态，此时线程的状态为TERMINATED，因为线程已经执行完毕。

线程同步

线程同步是指多个线程协同工作，共同完成任务。线程同步可以通过锁、信号量、条件变量等机制来实现。Java中常用的线程同步机制是锁，Java提供了synchronized关键字和Lock接口来实现锁。

synchronized关键字

synchronized关键字可以用来修饰方法或代码块，表示这个方法或代码块在某个时刻只能被一个线程执行。synchronized关键字使用了Java对象的内置锁（也称为监视器锁）来实现线程同步。

下面是一个使用synchronized关键字的例子：

class Counter {
  private int count;

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

  public synchronized int getCount() {
    return count;
  }
}

public class Main {
  public static void main(String[] args) throws InterruptedException {
    Counter counter = new Counter();
    Runnable task = () -> {
      for (int i = 0; i < 1000; i++) {
        counter.increment();
      }
    };
    Thread thread1 = new Thread(task);
    Thread thread2 = new Thread(task);
    thread1.start();
    thread2.start();
    thread1.join();
    thread2.join();
    System.out.println("Count: " + counter.getCount());
  }
}

在这个例子中，我们定义了一个Counter类，它有一个私有的count变量和两个同步方法increment()和getCount()。increment()方法和getCount()方法都使用了synchronized关键字来保证线程同步。在主线程中，我们创建了两个线程并将它们的任务都设置为对counter对象调用increment()方法。最后我们让主线程等待两个线程执行完毕后输出count变量的值。

Lock接口

Lock接口是Java中另一个常用的锁实现，它提供了更丰富的功能和更灵活的控制。Lock接口定义了lock()方法和unlock()方法，用来获取和释放锁。

下面是一个使用Lock接口的例子：

class Counter {
  private int count;
  private final Lock lock = new ReentrantLock();

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

  public int getCount() {
    lock.lock();