多线程—锁

    多线程中，锁用于确保同一时间只有一个线程可以访问共享资源，从而避免并发访问导致的数据不一致或者竞争条件等问题。

常见的锁有两种：互斥锁和读写锁。互斥锁的作用是保护共享资源，同时只允许一个线程访问，其他线程需要等待，直到该线程释放锁。读写锁可以同时允许多个线程读取共享资源，但只允许一个线程写入，其他线程需要等待写入完成。

在使用锁时需要注意以下几点：

1. 锁的使用应该尽可能简短，否则会影响程序性能。

2. 线程在获取锁时会被阻塞，在释放锁之前需要确保执行完成，否则可能会出现死锁。

3. 避免嵌套锁，即在已经获取锁的情况下再次获取锁，容易造成死锁。

4. 尽可能避免使用全局锁，应该尽可能使用局部锁，以减少锁的竞争。

当多个线程同时访问共享资源时，很容易发生数据竞争的问题，导致程序出错。因此，Java提供了多线程锁机制，来保证线程安全。

下面是一个简单的例子，演示如何使用Java多线程锁：

import java.util.concurrent.locks.ReentrantLock;

public class LockExample {
    private ReentrantLock lock = new ReentrantLock();
    private int count = 0;

    public void increment() {
        lock.lock(); // 获取锁
        try {
            count++;
        } finally {
            lock.unlock(); // 释放锁
        }
    }

    public int getCount() {
        return count;
    }
}

在这个例子中，我们使用了Java内置的ReentrantLock类创建了一个锁对象。在 increment 方法中，我们首先获取锁，然后执行加一操作，最后释放锁。这样，在多个线程同时访问 increment 方法时，只有一个线程能够获取到锁，其他线程则需要等待，直到锁释放后才能访问 increment 方法。

为了更清楚地演示锁的效果，我们可以创建多个线程来访问 LockExample 类的 increment 方法，如下所示：

public class Main {
    public static void main(String[] args) throws InterruptedException {
        LockExample example = new LockExample();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000000; i++) {
                example.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000000; i++) {
                example.increment();
            }
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println(example.getCount());
    }
}

在上面的代码中，我们创建了两个线程 t1 和 t2，分别对 LockExample 的实例对象执行了1000000次 increment 操作。由于 increment 方法上有锁保护，因此在两个线程执行过程中，只有一个线程能够获取到锁，另外一个则需要等待。最终，我们输出了 LockExample 的 count 属性值，可以看到它的值为2000000，说明并发操作是安全的。