实际工作中都是集群部署，通过负载均衡多台服务器工作，所以存在多个进程并发执行情况，而在每台服务器中又存在多个线程并发的情况，所以在java中锁分为 进程锁和线程锁，本文是对进程锁介绍，进程锁常见如下
基于文件的锁
基于文件的锁（FileLock）：多个进程共同访问某个文件，通过锁定一个文件来实现跨进程的互斥
示例代码
public class FileLockExample {
public static void main(String[] args) {
try (RandomAccessFile file = new RandomAccessFile("lockfile.lck", "rw");
FileChannel channel = file.getChannel()) {
// 尝试获取独占文件锁（阻塞直到获取成功）
FileLock lock = channel.lock();
try {
System.out.println("进程获取到文件锁，开始执行临界区操作...");
Thread.sleep(5000); // 模拟耗时操作
} finally {
lock.release();
System.out.println("进程释放文件锁");
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
优点：简单，无需额外依赖。
缺点：文件锁依赖文件系统，不同操作系统可能表现不同；需确保文件路径一致获取字节编码一致，比如windows系统和mac系统默认的字节编码格式就不同
基于Socket的锁
通过绑定端口实现单机进程互斥（不推荐，仅作演示）。
示例代码
import java.net.ServerSocket;
public class PortBasedLockExample {
private static final int LOCK_PORT = 12345;
public static void main(String[] args) {
try (ServerSocket serverSocket = new ServerSocket(LOCK_PORT)) {
System.out.println("进程获取到端口锁，开始执行临界区操作...");
Thread.sleep(5000); // 模拟耗时操作
} catch (Exception e) {
System.out.println("端口已被占用，其他进程正在运行");
}
}
}
优点：无需额外依赖。
缺点：不可靠，易受端口冲突影响；不适用于分布式环境。
数据库锁
多台服务器但是一般是用一个数据库的数据源，通过数据库的行锁或事务实现进程间的互斥。
示例代码（MySQL行锁）
public class DatabaseLockExample {
private static final String DB_URL = "jdbc:mysql://localhost:3306/mydb";
private static final String USER = "root";
private static final String PASS = "password";
public static void main(String[] args) {
try (Connection conn = DriverManager.getConnection(DB_URL, USER, PASS)) {
// 开启事务并锁定某一行
conn.setAutoCommit(false);
PreparedStatement stmt = conn.prepareStatement(
"SELECT * FROM locks WHERE lock_name = 'my_lock' FOR UPDATE"
);
ResultSet rs = stmt.executeQuery();
if (rs.next()) {
System.out.println("进程获取到数据库锁，开始执行临界区操作...");
Thread.sleep(5000); // 模拟耗时操作
}
conn.commit(); // 提交事务后释放锁
} catch (Exception e) {
e.printStackTrace();
}
}
}
优点：适用于分布式环境。
缺点：依赖数据库，需处理连接池和事务超时。
分布式锁
基于Redis的分布式锁
外部协调服务，使用Redis的SETNX命令或RedLock算法实现跨进程锁。
示例代码（Jedis实现）
import redis.clients.jedis.Jedis;
import redis.clients.jedis.params.SetParams;
public class RedisLockExample {
private static final String LOCK_KEY = "my_distributed_lock";
private static final String LOCK_VALUE = "locked";
private static final int LOCK_EXPIRE = 30000; // 锁超时时间（毫秒）
public static void main(String[] args) {
Jedis jedis = new Jedis("localhost", 6379);
try {
// 尝试获取锁（SETNX + 超时时间）
String result = jedis.set(LOCK_KEY, LOCK_VALUE,
SetParams.setParams().nx().px(LOCK_EXPIRE));
if ("OK".equals(result)) {
System.out.println("进程获取到Redis锁，开始执行临界区操作...");
Thread.sleep(5000); // 模拟耗时操作
} else {
System.out.println("获取锁失败，其他进程正在运行");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 释放锁（需使用Lua脚本确保原子性）
String script = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
"return redis.call('del', KEYS[1]) else return 0 end";
jedis.eval(script, 1, LOCK_KEY, LOCK_VALUE);
jedis.close();
}
}
}
优点：高性能，适用于分布式系统。
缺点：需处理锁续期、网络分区等问题（推荐使用Redisson库）。
基于ZooKeeper的分布式锁
外部协调服务，利用ZooKeeper的临时有序节点实现进程间协调。
示例代码（Curator框架）
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.locks.InterProcessMutex;
import org.apache.curator.retry.ExponentialBackoffRetry;
public class ZooKeeperLockExample {
private static final String ZK_ADDRESS = "localhost:2181";
private static final String LOCK_PATH = "/my_distributed_lock";
public static void main(String[] args) {
CuratorFramework client = CuratorFrameworkFactory.newClient(
ZK_ADDRESS, new ExponentialBackoffRetry(1000, 3));
client.start();
InterProcessMutex lock = new InterProcessMutex(client, LOCK_PATH);
try {
if (lock.acquire(10, java.util.concurrent.TimeUnit.SECONDS)) {
System.out.println("进程获取到ZooKeeper锁，开始执行临界区操作...");
Thread.sleep(5000); // 模拟耗时操作
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
lock.release();
} catch (Exception e) {
e.printStackTrace();
}
client.close();
}
}
}
优点：高可靠性，自动处理节点失效。
缺点：依赖ZooKeeper集群，性能低于Redis。
总结
根据具体场景选择合适的进程锁方案，分布式环境下推荐使用 Redis 或 ZooKeeper 实现！