当前位置：首页 > news >正文

java多线程（3.0）

news 来源：原创 2025/4/25 10:59:49

synchronized的使用方法

1.最常见的是synchronized 修饰代码块，并指定锁对象。

2.当 synchronized 修饰实例方法时，锁对象是当前实例（this）

3.当 synchronized 修饰静态方法时，锁对象是当前类的 Class类对象。对于一个类来说，只有一个唯一的calss类对象。

synchronized 的特性

互斥性

锁的可重入性

死锁的情况

如何避免死锁

编辑

上节课的时候我们讨论了多线程安全问题，讲到了关键字——synchronized,我们讲了其中的一种synchronized的使用方法，这节课我们先来学习它的其他用法

synchronized的使用方法

`1.最常见的是synchronized` 修饰代码块，并指定锁对象。

package thread;import java.util.Vector;class Counter {public int count = 0;public void add() {count++;}}public class Demo16 {public static void main(String[] args) throws InterruptedException {Counter counter = new Counter();Thread t1 = new Thread(() -> {for (int i = 0; i < 50000; i++) {synchronized (counter) {counter.add();}}});Thread t2 = new Thread(() -> {for (int i = 0; i < 50000; i++) {synchronized (counter) {counter.add();}}});t1.start();t2.start();t1.join();t2.join();System.out.println("counter=" + counter.count);}
}

2.当 `synchronized` 修饰实例方法时，锁对象是当前实例（`this`）

public class Counter {private int count = 0;public synchronized void increment() {count++;}//该代码约等于如下代码public  void increment() {synchronized（this）{count++;}
}public int getCount() {return count;}
}

多个线程调用同一个 Counter 实例的 increment() 方法时，同一时间只有一个线程能够执行该方法。

锁对象是当前实例（this）。

3.当 synchronized 修饰静态方法时，锁对象是当前类的 Class类对象。对于一个类来说，只有一个唯一的calss类对象。

public class Counter {private int count = 0;public static synchronized void increment() {count++;}//该代码约等于如下代码public static void increment() {synchronized（Counter.class）{count++;}
}public int getCount() {return count;}
}

`synchronized` 的特性

互斥性

synchronized 确保同一时间只有一个线程能够执行被保护的代码块或方法。

其他线程必须等待当前线程释放锁后才能获取锁并执行代码。

锁的可重入性
static class Counter {public int count = 0;synchronized void increase() {count++;}synchronized void increase2() {increase();}
}
如果用该代码，按照之前对于锁的设定, 第二次加锁的时候, 该线程就会阻塞等待. 直到第一次的锁被释放, 才能获取到第二个锁. 但是释放第一个锁也是由该线程来完成, 结果这个线程已经堵塞了, 也就无法进行解锁操作. 这时候就会死锁.
这样的锁称为不可重入锁.

那么可重入锁就是
• 一个对象可以多次在同一个线程内连续加锁，而不会导致死锁。
• 在同一个线程连续加锁时，每次加锁，锁的计数器加 1；每次释放锁时，计数器减 1。只有当计数器为 0 时，锁才会被完全释放。

死锁的情况

虽然在synchronized中连续加锁不会出现死锁，但还有其他很多情况会出现死锁，

比如嵌套锁导致的死锁

package thread;public class Demo17 {private static Object locker1 = new Object();private static Object locker2 = new Object();public static void main(String[] args) {Thread t1 = new Thread(() -> {synchronized (locker1) {System.out.println("t1 加锁 locker1 完成");// 这里的 sleep 是为了确保, t1 和 t2 都先分别拿到 locker1 和 locker2 然后在分别拿对方的锁.// 如果没有 sleep 执行顺序就不可控, 可能出现某个线程一口气拿到两把锁, 另一个线程还没执行呢, 无法构造出死锁.try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}synchronized (locker2) {System.out.println("t1 加锁 locker2 完成");}}});Thread t2 = new Thread(() -> {synchronized (locker1) {System.out.println("t2 加锁 locker1 完成");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}synchronized (locker2) {System.out.println("t2 加锁 locker2 完成");}}});t1.start();t2.start();}
}

运行这段代码后，程序会陷入死锁

死锁原因

线程1 先获取了 lock1，然后试图获取 lock2。

线程2 先获取了 lock2，然后试图获取 lock1。

此时，线程1和线程2都在等待对方释放锁，但它们又都持有对方需要的锁，导致死锁。

如何避免死锁

经典案例：哲学家吃面条问题；

避免死锁问题只需要打破上述四点的其中一点即可，对于第一点和第二点对于Java中是打破不了的，他们都是synchronized的基本特性
从第三点来看，不要让锁嵌套获取即可（但是有的时候必须嵌套，那就破除循环等待）
第四点破除循环等待：约定好加锁的顺序，让所有的线程都按照约定要的顺序来获取锁。

避免死锁问题只需要打破上述四点的其中一点即可，对于第一点和第二点对于Java中是打破不了的，他们都是synchronized的基本特性
从第三点来看，不要让锁嵌套获取即可（但是有的时候必须嵌套，那就破除循环等待）
第四点破除循环等待：约定好加锁的顺序，让所有的线程都按照约定要的顺序来获取锁。