进程与线程的基础（2）（锁：synchronized）

@@@wang

已于 2024-08-11 20:03:48 修改

阅读量783

点赞数 17

文章标签： java

于 2024-04-28 21:13:48 首次发布

本文链接：https://blog.csdn.net/2201_76027754/article/details/138289734

版权

前言：

加锁是解决多线程安全问题的一个重要方式，通过加锁可以让某些操作变成原子的操作，从而解决多线程安全问题，但是对某些线程进行多次加锁的时候，可能会出现死锁。当一个锁处于被加锁状态，如果有另一个线程也想要获取到这把锁的话就会产生“锁冲突/锁竞争”，后一个线程就会进入阻塞等待，直到前一个线程释放了该锁为止。如果这两个线程互相“不让对方”，那么此时就会出现死锁！！

1.加锁的基本方式

synchronized() {
   //你所想要实现的内容
}

ps：括号里需要一个用来加锁的对象，这个对象是啥不重要（任意对象），重要的是通过这个对像来区分两个线程是否在竞争同一把锁。

除了上述synchronized修饰代码块之外，还可以修饰实例方法/静态方法

//修饰实例方法,this可以作为锁对象进行加锁
public void increase1 () {
    synchronized(this) {
        count++;
    }    
}

synchronized public void increase2 () {
    count++;
}


//修饰静态方法,相当于针对类对象进行加锁
//Counter是自己创建的一个类，Counter.class就表示类对象
public static void increase3 () {
    synchronized(Counter.class) {
        count++;
    }    
}

synchronized public static void increase4 () {
    count++;
}

java里面所创建的对象，在对应的内存空间当中，除了你自己定义的一些属性，还有一些自带属性。比如说synchronized用的锁的对象就是一个，其中有表示当前对是否已经进行加锁。

2.锁的重要特性

synchronized的相关锁特性是可重入的。所谓可重入就是指一个线程针对一把锁，加锁两次，不会出现死锁，满足这个要求就称可重入，否则不可重入。而不可重入就会造成死锁，所以在实际生存过程中，应该避免这个问题。

3.死锁（锁的不可重入性）

（1）一个线程，多次加锁 ==> 会造成死锁

看下面一段代码：

public class test{
    Object locker = new Object();
    Thread t = new Thread(() -> {
       synchronized (locker) {
           try {
               Thread.sleep(500);
           }catch (InterruptedException e) {
               e.printStackTrace();
           }
           synchronized (locker) {
               try {
                   Thread.sleep(500);
               }catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       }
    });
}

我们可以从这段代码中看出只有一个锁对象那就是locker，第二次想要加锁成功就需要第一次加锁然后将锁给释放掉，而第一次想要释放锁，就需要执行完整个语句，要执行到语句的最后就需要给第二次加锁成功，此时代码才可以继续执行，这里由于第一次并没有释放锁，导致第二次加锁失败，此时线程进行阻塞。这就形成了死锁！！

（2）两个线程，两把锁

如果是嵌套关系，就可能会造成死锁。

public static void main(String[] args) {
        Object locker1 = new Object();
        Object locker2 = new Object();
        Thread t1 = new Thread(() -> {
            synchronized (locker1) {
                try {
                    Thread.sleep(500);
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (locker2) {
                    System.out.println("t1正在执行");
                }
            }
        });
        Thread t2 = new Thread(() -> {
            synchronized (locker2) {
                try {
                    Thread.sleep(500);
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (locker1) {
                    System.out.println("t2正在执行");
                }
            }
        });
        t1.start();
        t2.start();
}

运行结果：

运行代码可以发现没有打印任何东西，因为此时就出现了死锁！！

如果是并列关系，就不会出现死锁。

public static void main(String[] args) {
        Object locker1 = new Object();
        Object locker2 = new Object();
        Thread t1 = new Thread(() -> {
            synchronized (locker1) {
                try {
                    Thread.sleep(500);
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (locker2) {
                    System.out.println("t1正在执行");
                }
            }
        });
        Thread t2 = new Thread(() -> {
            synchronized (locker1) {
                try {
                    Thread.sleep(500);
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (locker2) {
                    System.out.println("t2正在执行");
                }
            }
        });
        t1.start();
        t2.start();
    }

运行结果：