重入锁的作用是什么？

重入锁是一种高级锁，也叫可重入锁或递归锁。它允许线程如同拥有某个资源而不被其他线程所interrupt而阻塞。重入锁为控制多个线程互斥访问共享资源提供了更加高级的功能，相较于传统的synchronized锁，它具有更高的并发性和更强的扩展性。

为了更好的说明重入锁的作用，我们需要先理解重入锁的几个特性：

1. 可重入性：线程可以再次获取已经持有的锁。

2. 公平/非公平：该锁支持公平和非公平获取锁的机制。

3. 中断响应：当线程持有锁的时候，能够响应中断请求。

4. 尝试非阻塞获取锁：尝试非阻塞地获取锁，如果这一时刻没有被其他线程持有，则成功获取并持有锁。

重入锁被广泛应用于一些需求多线程访问同一资源的场景，如下所示的几个示例：

1. 实现递归锁：

重入锁的一个典型应用是实现递归锁。递归锁指的是一个线程可以在持有锁的情况下调用该锁的同步方法或者代码块，而不必担心死锁的情况。

import java.util.concurrent.locks.ReentrantLock;

public class RecursionExample {

    private ReentrantLock lock = new ReentrantLock();

    public void outer() {
        lock.lock();      // 获取锁
        try {
            inner();      // 调用锁的同步方法inner，这里不会发生死锁
        } finally {
            lock.unlock(); // 释放锁
        }
    }

    public void inner() {
        lock.lock();      // 再次获取锁，进入递归锁模式
        try {
            // do something
        } finally {
            lock.unlock(); // 释放锁
        }
    }
}

1. 控制线程的并发执行：

在并发编程中，有时需要控制线程的执行顺序。使用重入锁可以让线程提交操作的时间有序，避免出现重要任务被非常重要的小任务所阻塞的情况。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantLock;

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

    public static void main(String[] args) {
        ExecutionOrderExample example = new ExecutionOrderExample();
        example.runTasks();
    }

    private void runTasks() {
        ExecutorService pool = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 5; i++) {
            pool.execute(new Task(i));
        }
        pool.shutdown();
    }

    private class Task implements Runnable {
        private int id;

        public Task(int id) {
            this.id = id;
        }

        @Override
        public void run() {
            lock.lock();
            try {
                while (count != id) {
                    Thread.sleep(10);
                }
                count++;

                System.out.printf("task id=%d, count=%d%n", id, count);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
}

在这个例子中，我们使用重入锁来保证多个线程的操作时间有序，并且避免了由于线程调度带来的不可预测性。

以上就是重入锁的两个示例应用，实际上重入锁在实际开发中还有很多使用场景，比如线程同步、死锁避免、高并发操作等，可根据不同的需求合理运用重入锁，以提高程序的稳定性和性能。