Java基础之并发相关知识总结

什么是并发？

并发是指多个线程在特定的时间段内运行，并且在同一个进程内共享资源。本质上，线程是 CPU 执行计算任务的最小单位，CPU 在多个线程之间切换运行，从而实现并发执行多个任务，提高系统的效率和吞吐量。

什么是线程？

线程是进程内部并发执行的一条路径，也是执行的最小单位。在 Java 中，一个程序至少有一个主线程，主线程会调用其他线程来完成特定的任务。

如何创建线程？

Java 中有两种创建线程的方式，一种是继承 Thread 类，另一种是实现 Runnable 接口。

• 继承 Thread 类

java
class MyThread extends Thread {
@Override
public void run() {
// 线程执行的代码
}
}

• 实现 Runnable 接口

java
class MyRunnable implements Runnable {
@Override
public void run() {
// 线程执行的代码
}
}
Thread thread = new Thread(new MyRunnable());
thread.start(); // 启动线程

如何控制线程？

在 Java 中，有几种常见的线程控制方式，包括睡眠、暂停、停止等。

• 睡眠

java
try {
Thread.sleep(1000); // 睡眠一秒
} catch (InterruptedException e) {
e.printStackTrace();
}

• 暂停

java
Thread.yield(); // 线程暂停

• 停止

java
thread.stop(); // 停止线程

注意：强制停止线程的方式不是很安全，推荐使用通过设置标志位的方式来控制线程的暂停和停止。

如何实现线程同步？

在多线程的情况下，由于多个线程共享资源，可能会出现线程安全的问题，就需要采用线程同步的方式来保证数据的安全性。

Java 中提供了两种常见的线程同步方式，一种是使用 synchronized 关键字，另一种是使用 Lock 对象。

使用 synchronized 关键字实现线程同步

class MyTask implements Runnable {
      private int tickets = 20;

      @Override
      public void run() {
          while (tickets > 0) {
              synchronized (this) { // 加锁
                  if (tickets > 0) {
                      System.out.println(Thread.currentThread().getName() + " 卖出了第 " + tickets + " 张车票");
                      tickets--;
                  }
              }
          }
      }
  }

使用 Lock 对象实现线程同步

class MyTask implements Runnable {
      private int tickets = 20;
      private Lock lock = new ReentrantLock(); // 创建 Lock 对象

      @Override
      public void run() {
          while (tickets > 0) {
              lock.lock(); // 加锁
              try {
                  if (tickets > 0) {
                      System.out.println(Thread.currentThread().getName() + " 卖出了第 " + tickets + " 张车票");
                      tickets--;
                  }
              } finally {
                  lock.unlock(); // 解锁
              }
          }
      }
  }

使用 Lock 对象相较于 synchronized 关键字来说，具有更强的扩展性和灵活性。

如何实现线程间通信？

在多线程的情况下，可能需要实现线程间的通信，以完成某些复杂的操作。

在 Java 中，可以通过使用 wait()、notify() 和 notifyAll() 方法来实现线程间通信。

如下是示例代码：

class ClassA {
      public synchronized void methodA() {
          try {
              System.out.println("开始执行 methodA");
              wait();
              System.out.println("methodA 执行完成");
          } catch (InterruptedException ex) {
              ex.printStackTrace();
          }
      }

      public synchronized void methodB() {
          try {
              System.out.println("开始执行 methodB");
              notifyAll();
              System.out.println("methodB 执行完成");
          } catch (Exception ex) {
              ex.printStackTrace();
          }
      }
  }

在上述代码中，ClassA 中的 methodA() 方法执行完之后就会进入等待队列，直到其他线程调用 ClassA 中的 notify() 或 notifyAll() 方法来唤醒等待队列中的线程。同时，ClassA 中的 methodB() 方法会调用 notify() 或 notifyAll() 方法来唤醒等待的线程。

总结

以上就是 Java 基础之并发相关知识总结的全部内容。

在多线程的情况下，需要考虑线程安全和线程间通信的问题，通过使用 synchronized 关键字或 Lock 对象来实现线程同步，通过使用 wait()、notify() 和 notifyAll() 方法来实现线程间通信。