Java中的synchronized锁

以你之姓@ 2023-10-13 11:53 17阅读 0赞

**目录**

简介

注意：

1.如果synchronized锁加在实例方法上，则默认使用的是this锁

2.如果synchronized锁加载静态方法上，则默认使用的是 类名.class 锁（Java反射技术中说到一个class文件只会在jvm中存在一份）

3.死锁问题：在使用synchronized锁嵌套的时候，要避免死锁问题：

--------------------

## 简介 ##

> 在Java中，synchronized是一种关键字，用于实现线程同步。它可以用于方法或代码块，用于保证同一时间只有一个线程可以执行被synchronized修饰的代码。
> 
> synchronized的锁机制有两种使用方式：
> 
> 1. 同步方法：可以在方法声明中使用synchronized关键字。当一个线程调用同步方法时，会自动获取该方法所属对象的锁，其他线程将被阻塞，直到该线程释放锁为止。
> 
> 示例：
> 
>     public synchronized void synchronizedMethod(){
>         // 同步代码块
>     }
>     ```
> 
> 2. 同步代码块：使用synchronized关键字可以修饰一段代码块。当一个线程进入synchronized代码块时，它会尝试获取锁，如果锁已经被其他线程获取，那么该线程将被阻塞，直到锁被释放。
> 
> 示例：
> 
>     private Object lock = new Object();
>     
>     public void synchronizedBlock(){
>         synchronized(lock){
>             // 同步代码块
>         }
>     }
>     ```
> 
> 需要注意的是，synchronized锁是基于对象的，每个对象都有一个关联的锁。当多个线程同时访问某个对象的同步方法或同步代码块时，它们会竞争该对象的锁。
> 
> 另外，要注意避免过多地使用synchronized，因为过多的同步操作可能会导致性能下降。在某些情况下，可以考虑使用更灵活的并发工具，如Lock和Condition接口。
> 
> 总之，synchronized是Java中用于实现线程同步的关键字，通过对方法或代码块进行同步，可以确保同一时间只有一个线程执行同步代码，从而保证线程安全。

## 注意： ##

### 1.如果synchronized锁加在实例方法上，则默认使用的是this锁 ###

### 2.如果synchronized锁加载静态方法上，则默认使用的是 类名.class 锁（Java反射技术中说到一个class文件只会在jvm中存在一份） ###

### 3.死锁问题：在使用synchronized锁嵌套的时候，要避免死锁问题： ###

解决方案：

解决死锁问题的方法可以是以下几种：

1. 优化资源请求顺序：通过约定和统一的资源请求顺序，可以避免循环等待的情况发生。

2. 使用超时机制：在请求资源时，设置一个超时时间，在等待超过一定时间后放弃当前的资源请求，释放已持有的资源，然后重新尝试获取资源。

3. 使用资源分级：将资源进行划分，按照资源层级进行请求，确保每个线程只会请求当前层级的资源，防止多层级的资源竞争导致死锁。

4. 引入死锁检测算法：通过算法检测系统中是否存在死锁，并采取相应的措施解除死锁，例如资源剥夺、撤销进程等。

5. 使用Lock机制：使用Lock和Condition接口提供的功能来代替synchronized关键字，给予更灵活的控制，以避免发生死锁。

6. 尽量减少同步资源的使用：在设计时避免过多地使用同步资源，使用无锁算法或者减少共享资源的需求，可以降低发生死锁的概率。

7. 编写良好的代码和设计：遵循良好的编程原则和设计模式，减少不必要的资源竞争，尽量简化复杂的依赖关系，从根本上减少死锁的发生。

需要注意的是，死锁是一个复杂的问题，没有一种通用的解决方案适用于所有情况。因此，在编写多线程程序时，应该综合考虑业务逻辑和代码结构，并使用适当的方法来避免和处理死锁情况。

死锁案例：

package lzx6;
    
    public class DeadlockExample {
        private static final Object resource1 = new Object();
        private static final Object resource2 = new Object();
    
        public static void main(String[] args) {
            Thread thread1 = new Thread(() -> {
                synchronized (resource1) {
                    System.out.println("Thread 1: Holding resource 1...");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("Thread 1: Waiting for resource 2...");
                    synchronized (resource2) {
                        System.out.println("Thread 1: Holding resource 1 and 2...");
                    }
                }
            });
    
            Thread thread2 = new Thread(() -> {
                synchronized (resource2) {
                    System.out.println("Thread 2: Holding resource 2...");
                    try {
                        Thread.sleep(1000);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    System.out.println("Thread 2: Waiting for resource 1...");
                    synchronized (resource1) {
                        System.out.println("Thread 2: Holding resource 2 and 1...");
                    }
                }
            });
    
            thread1.start();
            thread2.start();
        }
    }

运行结果：

![16abd88931754fb7873a874ea423f966.png][]

两个线程都在等待对方释放资源，所以两个线程都发生了死锁卡住了。

[16abd88931754fb7873a874ea423f966.png]: https://img-blog.csdnimg.cn/16abd88931754fb7873a874ea423f966.png