互斥锁
互斥锁(Mutex Lock)是一种同步机制,用于确保在任何时刻只有一个线程可以访问特定的代码段(临界区),从而防止数据竞争和不一致性。
使用方法:
- 在Java中,可以使用
synchronized
关键字或ReentrantLock
类来实现互斥锁。 - 使用
lock()
方法获取锁,使用unlock()
方法释放锁。
特点:
- 确保线程安全,防止多个线程同时访问共享资源。
- 简单易用,但需要注意锁的粒度和性能影响。
示例:
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class MutexExample {
private static int counter = 0; // 定义一个共享资源,初始值为0
private static Lock lock = new ReentrantLock(); // 定义一个可重入锁
public static void main(String[] args) {
Thread[] threads = new Thread[10]; // 创建一个包含10个线程的数组
for (int i = 0; i < 10; i++) {
threads[i] = new Thread(() -> {
lock.lock(); // 获取锁,确保同一时间只有一个线程可以执行下面的代码
try {
counter++; // 访问并修改共享资源
System.out.println("Counter value: " + counter); // 打印当前计数器的值
} finally {
lock.unlock(); // 释放锁,确保锁一定会被释放,避免死锁
}
});
threads[i].start(); // 启动线程
}
for (int i = 0; i < 10; i++) {
try {
threads[i].join(); // 等待所有线程执行完毕
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
线程死锁
线程死锁(Deadlock)是指两个或多个线程互相等待对方释放资源,导致所有相关线程都无法继续执行的状态。
产生条件:
- 互斥条件:资源不能被共享,一次只能被一个线程使用。
- 占有并等待:线程已经占有至少一个资源,并等待获取其他线程占有的资源。
- 不可抢占:资源不能被强制抢占,只能由占有它的线程主动释放。
- 循环等待:存在一个线程资源的循环链,每个线程都在等待链中下一个线程占有的资源。
示例:
public class DeadlockExample {
private static Object lock1 = new Object(); // 定义第一个锁对象
private static Object lock2 = new Object(); // 定义第二个锁对象
public static void main(String[] args) {
Thread thread1 = new Thread(() -> {
synchronized (lock1) { // 获取第一个锁
System.out.println("Thread 1: Holding lock 1...");
try { Thread.sleep(10); } catch (InterruptedException e) {} // 模拟一些工作
System.out.println("Thread 1: Waiting for lock 2...");
synchronized (lock2) { // 尝试获取第二个锁
System.out.println("Thread 1: Holding lock 1 & 2...");
}
}
});
Thread thread2 = new Thread(() -> {
synchronized (lock2) { // 获取第二个锁
System.out.println("Thread 2: Holding lock 2...");
try { Thread.sleep(10); } catch (InterruptedException e) {} // 模拟一些工作
System.out.println("Thread 2: Waiting for lock 1...");
synchronized (lock1) { // 尝试获取第一个锁
System.out.println("Thread 2: Holding lock 1 & 2...");
}
}
});
thread1.start(); // 启动第一个线程
thread2.start(); // 启动第二个线程
}
}
释放锁
释放锁是指线程在完成对共享资源的访问后,主动将锁释放,以便其他线程可以获取锁并访问资源。
使用方法:
- 在Java中,使用
unlock()
方法释放锁。 - 确保在
finally
块中释放锁,以防止资源泄漏。
特点:
- 确保资源能够被其他线程访问,避免资源被永久占用。
- 需要谨慎处理,确保锁的释放顺序正确,避免死锁。
示例:
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ReleaseLockExample {
private static Lock lock = new ReentrantLock(); // 定义一个可重入锁
public static void main(String[] args) {
lock.lock(); // 获取锁
try {
// 访问共享资源
System.out.println("Accessing shared resource...");
} finally {
lock.unlock(); // 释放锁,确保锁一定会被释放,避免死锁
System.out.println("Lock released.");
}
}
}
总结
理解这些是很重要的,在开发中我们要避免死锁,谨慎处理线程。