【Java 基础】21 多线程同步与锁

用多线程过程中，有可能出现 多个线程同时处理（获取或修改等）同一个数据，这个时候就 会发生数据不同步的问题， 因此出现了同步和锁来保证多个线程可以安全的处理同一个数据。

1.存在的问题

例如：火车售票窗口售票，假如我们有 2 个窗口（相当于开启了 2 个线程），同时卖 10 张票

两个窗口的操作流程都如下：

1）购票者到窗口

2）窗口访问票匣子获取余票数量

3）票匣子返回余票数量

4）售票窗口判断，若存在票（大于 0 ）则卖给他

那么，假如票匣子就剩下 1 张票啦！但是不巧的是两个窗口同时查看余票数量，都发现还有 1 张票，**又都卖给了购票者……**这就是多线程存在的数据不同步问题^_

示例代码：

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        ThreadDemo threadDemo = new ThreadDemo();
        new Thread(threadDemo,"售票窗口1").start();
        new Thread(threadDemo,"售票窗口2").start();
    }
}

class ThreadDemo implements Runnable {
    private int ticketCount = 10;
    @Override
    public void run() {
        String tName = Thread.currentThread().getName();
        while (true) {
            if (ticketCount <= 0) {
                return;
            }
            try {
                Thread.sleep(200);
                System.out.println(tName + "成功卖了一张票！余票:" + (ticketCount-- - 1));
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

输出结果：

售票窗口1成功卖了一张票！余票:9
售票窗口2成功卖了一张票！余票:8
售票窗口1成功卖了一张票！余票:7
售票窗口2成功卖了一张票！余票:6
售票窗口2成功卖了一张票！余票:5
售票窗口1成功卖了一张票！余票:4
售票窗口2成功卖了一张票！余票:3
售票窗口1成功卖了一张票！余票:2
售票窗口1成功卖了一张票！余票:1
售票窗口2成功卖了一张票！余票:0
售票窗口1成功卖了一张票！余票:-1

2.使用同步解决问题

同步（Synchronization） 是一种协调多个线程执行的机制，它能够确保在同一时刻只有一个线程访问共享资源。主要通过关键字 synchronized 和 volatile 以及 锁对象 等手段来实现同步。

1) synchronized

关键字 synchronized 用于修饰方法或代码块，保证在同一时刻只有一个线程能够执行被 synchronized 修饰的代码。以下是两种使用方式：

• 修饰方法

public synchronized void test() {
    // 同步的代码块
}

• 修饰代码块

public void someMethod() {
    // 非同步的代码块

    synchronized (lockObject) {
        // 同步的代码块
    }

    // 非同步的代码块
}

2) volatile

关键字 volatile 用于声明变量，保证变量的可见性。被 volatile 修饰的变量对所有线程可见，当一个线程修改了这个变量的值，其他线程能够立即看到修改后的值。

public class Demo {
    private volatile int ticketCount = 10;
}

3) 锁

Java 提供了很多种锁，常用的有 synchronized 关键字、ReentrantLock 及 Read/Write Lock 等 。

• ReentrantLock

  它支持可重入锁，允许一个线程多次获取同一把锁。

  import java.util.concurrent.locks.Lock;
  import java.util.concurrent.locks.ReentrantLock;
  
  public class Demo {
      private final Lock lock = new ReentrantLock();
  
      public void test() {
          lock.lock();
          try {
              // 同步的代码块
          } finally {
              lock.unlock();
          }
      }
  }
  

  ReentrantLock 提供了比 synchronized 更丰富的功能，如可中断锁、公平锁、定时锁等

• Read/Write Lock

  ReadWriteLock 接口定义了读写锁，它包含两个锁，一个用于读操作，一个用于写操作。读写锁允许多个线程同时读取共享资源，但只允许一个线程进行写操作。ReentrantReadWriteLock 是 ReadWriteLock 的一个实现类

  import java.util.concurrent.locks.ReadWriteLock;
  import java.util.concurrent.locks.ReentrantReadWriteLock;
  
  public class Demo {
      private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
      public void read() {
          readWriteLock.readLock().lock();
          try {
              // 读取共享资源的操作
          } finally {
              readWriteLock.readLock().unlock();
          }
      }
      public void write() {
          readWriteLock.writeLock().lock();
          try {
              // 修改共享资源的操作
          } finally {
              readWriteLock.writeLock().unlock();
          }
      }
  }
  

  读写锁适用于读操作远远多于写操作的场景，可以提高并发性

• StampedLock

  它是一种读写锁的变种，提供了乐观读锁，可以在读多写少的场景中提供更好的性能

  import java.util.concurrent.locks.StampedLock;
  
  public class Demo {
      private final StampedLock stampedLock = new StampedLock();
      public void read() {
          long stamp = stampedLock.tryOptimisticRead();
          // 乐观读操作
          if (!stampedLock.validate(stamp)) {
              // 有写操作发生，转为悲观读
              stamp = stampedLock.readLock();
              try {
                  // 悲观读操作
              } finally {
                  stampedLock.unlockRead(stamp);
              }
          }
      }
      public void write() {
          long stamp = stampedLock.writeLock();
          try {
              // 写操作
          } finally {
              stampedLock.unlockWrite(stamp);
          }
      }
  }
  

  StampedLock 提供了更细粒度的控制，并允许在不同的代码路径中执行不同的操作

总结

在多线程编程中，确保线程安全是至关重要的！通过合理使用 synchronized 关键字、volatile 关键字以及 ReentrantLock 等锁机制，可以有效地保护共享资源，避免数据不一致和竞态条件等问题。合理的同步机制不仅能够提高程序的性能，还能够确保程序的正确性。在实际开发中，根据具体场景选择合适的同步和锁机制是编写高效、安全多线程代码的关键。