【JavaEE】【多线程】synchronized和死锁

news2024/10/21 11:53:56

一、synchronized详解

1.1 互斥

synchronized 会起到互斥效果, 某个线程执行到某个对象的 synchronized 中时, 其他线程如果也执行到
同一个对象 synchronized 就会阻塞等待.

语法：

synchronized(变量){
//修改操作
}

()括号内的变量不重要，作用是区分加锁对象是否一样，如果对同一个对象加锁，那么两个操作就会产生“blocked”锁竞争阻塞问题，后一个线程就会等到前一个线程解锁再执行。
进入左大括号 ‘{’ 就是加锁，出了右大括号 ‘}’ 就是解锁。

写一个例子，就会出现预期结果10000:

public class Demo7 {
    private static int ret;
    public static void main(String[] args) throws InterruptedException {
        Object block = new Object();
        
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {                
                synchronized (block){
                    ret++;
                }
                
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                synchronized (block){
                    ret++;
                }

            }
        });
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println(ret);;
    }
}

synchronized还可以修饰方法（静态方法也行）。

synchronized修饰实例方法：

class Counter{
    public int ret;
    public void increase1() {
        synchronized (this) {
            ret++;
        }
    }
    //简化版本
    synchronized public void increase2() {
        ret++;
    }
}

synchronized修饰静态方法：相当于修饰这个类

class Counter{
	private static int ret2;
	public static void increase3() {
        synchronized (Counter.class) {
            ret2++;
        }
    }
    //简化版本
    synchronized public static void increase4() {
        ret2++;
    }
}

1.2 可重入

可重入就是指一个线程连续针对一个对象加多次锁，不会出现“死锁”现象称为可重入。

死锁：自己把自己锁死。
举个例子，假如synchronized不是可重入锁：

synchronized (block) {
	synchronized(block) {
	//代码
	} //右大括号}2
}  //右大括号}1

在进入第一个synchronized的时候，加上一把锁，此时已经是“锁定状态”，
当我们进入到第二个synchronized的时候要加锁，就发生“阻塞等待”，就要等到第一个锁走到右大括号}1解完锁才能加，
然而第一个锁走到右大括号}1解锁，又需要第二把锁创建走完到右大括号}2。
这是线程就卡死了，这就是死锁。

synchronized 同步块对同一条线程来说是可重入的，不会出现自己把自己锁死的问题；

可重入机制会在第一次加锁的时候记录是那个线程加的锁，然后下一次加锁如果是这个被记录线程，就直接加锁成功。这就是可重入锁的 "线程持有者"信息。
可重入锁还会有一个“计数器”信息，加一把锁就加一，解一把锁就减一，当计数器递减为 0 的时候, 才真正释放锁。

二、死锁

前面所说，一个线程两把锁，如果不是可重入锁就死锁了；
还有两个线程两把锁，是不是可重入锁都要死锁。两个线程T1、T2，两把锁A、B；T1获取锁A，T2获取锁B，T2尝试获取锁B，T2尝试获取锁A。就如“车钥匙锁房间里了，房间钥匙锁车里了”。

public class Demo9 {
    public static void main(String[] args) {
        Object block1 = new Object();
        Object block2 = new Object();
        Thread thread1 = new Thread(()->{
            synchronized (block1) {
                System.out.println("thread1加block1");
                synchronized (block2) {
                    System.out.println("thread1加block2");
                }
            }
        });
        Thread thread2 = new Thread(()->{

            synchronized (block2) {
                System.out.println("thread2加block2");

                synchronized (block1) {
                    System.out.println("thread2加block1");
                }
            }
        });
        thread1.start();
        thread2.start();
    }
}