网站改版 百度影响网站推广怎么推广

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

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;@Overridepublic 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 等锁机制，可以有效地保护共享资源，避免数据不一致和竞态条件等问题。合理的同步机制不仅能够提高程序的性能，还能够确保程序的正确性。在实际开发中，根据具体场景选择合适的同步和锁机制是编写高效、安全多线程代码的关键。