什么是自旋锁SpinLock

自旋锁（Spin Lock）是一种基于忙等待的锁机制，它是一种轻量级的锁实现方式。与传统的阻塞锁不同，自旋锁在获取锁时不会主动阻塞线程，而是通过循环不断地尝试获取锁，直到成功获取为止。

在多核处理器的环境下，自旋锁通常会使用底层的原子操作（如CAS）来实现。当一个线程尝试获取自旋锁时，如果发现锁已经被其他线程持有，它会在循环中不断地检查锁的状态，而不是被挂起或阻塞。这样做的目的是为了避免线程被切换到其他任务上，从而减少上下文切换的开销。

自旋锁适用于以下情况：

1. 锁的保持时间很短：如果临界区的代码执行时间很短，使用自旋锁可以避免线程切换的开销，从而提高性能。

2. 并发冲突较少：自旋锁适用于并发冲突较少的情况。如果临界区的竞争激烈，自旋锁可能会导致大量的线程空转，浪费CPU资源。

3. 不可阻塞：自旋锁要求获取锁的操作是非阻塞的，即不会引起线程的挂起或阻塞。如果获取锁的操作可能会引起线程的阻塞，使用自旋锁就不合适，应该选择其他类型的锁。

需要注意的是，自旋锁在等待期间会占用CPU资源，因此适合于临界区代码执行时间短、并发冲突较少的情况。如果临界区的执行时间较长，或者并发冲突较多，使用自旋锁可能会导致性能下降。此外，自旋锁还可能引发活跃性问题，如死锁或饥饿，因此在使用自旋锁时需要仔细考虑并发场景和锁的使用方式。

以下是一个使用自旋锁的简单示例： 

import java.util.concurrent.atomic.AtomicBoolean;

public class SpinLock {
    private AtomicBoolean locked = new AtomicBoolean(false);

    public void lock() {
        while (!locked.compareAndSet(false, true)) {
            // 自旋等待锁释放
        }
    }

    public void unlock() {
        locked.set(false);
    }
}

在上述代码中，我们使用AtomicBoolean类来实现自旋锁。AtomicBoolean提供了原子性的操作，我们使用它来表示锁的状态。

在lock()方法中，使用compareAndSet(false, true)来尝试获取锁。如果锁已经被其他线程持有，则compareAndSet()方法会返回false，进入自旋等待状态，不断尝试获取锁。一旦成功获取锁（即compareAndSet()返回true），则退出循环，表示锁已经被当前线程获取。

在unlock()方法中，将锁的状态设置为false，表示锁已释放。

下面是一个使用自旋锁的示例，模拟了两个线程并发访问共享变量：

public class SpinLockExample {
    private static int counter = 0;
    private static SpinLock spinLock = new SpinLock();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 100000; i++) {
                spinLock.lock();
                counter++;
                spinLock.unlock();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 100000; i++) {
                spinLock.lock();
                counter--;
                spinLock.unlock();
            }
        });

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Counter: " + counter);
    }
}

在上述示例中，我们创建了两个线程分别对共享变量counter进行自增和自减操作。通过使用自旋锁spinLock来保护对counter的并发访问，确保每次操作的原子性。

需要注意的是，自旋等待的过程会占用CPU资源，因此在实际应用中，需要根据具体的场景和需求来选择合适的锁机制。自旋锁适用于临界区执行时间短、并发冲突较少的情况。

 加锁的时候，如果是空的，则将线程丢进去，将其无限循环，就是自旋锁

解锁的时候，如果是期望的线程，我们就将其设为空