12.synchronized加在方法上

那个松鼠很眼熟w

705人浏览 · 2025-10-11 13:13:10

那个松鼠很眼熟w · 2025-10-11 13:13:10 发布

synchronized语法

加在实例方法上

相当于锁住对象本身

public synchronized int getCount() {
       return this.count;
}
//等价于
public int getCount() {
    synchronized (this){
        return this.count;
    }
}

加在静态方法上

相当于锁住类对象

public synchronized static void test(){
    
}

//等价于
public  static void test(){
    synchronized (Main.class){
        
    }
}

所谓的“线程八锁”

就是考察synchronized 锁住的是哪个对象

1

public class Test {
    public static void main(String[] args) {
        Number number = new Number();
        Thread t1 = new Thread() {
            @Override
            public void run() {
                number.a();
            }
        };
        Thread t2 = new Thread() {
            @Override
            public void run() {
                number.b();
            }
        };

        t1.start();
        t2.start();
    }

}

@Slf4j(topic = "c.Number")
class Number {

    public synchronized void a() {
        log.debug("1");
    }

    public synchronized void b() {
        log.debug("2");
    }

}

a方法和b方法的synchronized 都是锁住当前对象，所以最终打印顺序可能是先1后2，或者先2后1，就看CPU先调度谁

2025-10-11 14:02:06.998 [Thread-0] c.Number - 1
2025-10-11 14:02:07.000 [Thread-1] c.Number - 2

2025-10-11 14:05:44.771 [Thread-1] c.Number - 2
2025-10-11 14:05:44.771 [Thread-0] c.Number - 1

2

public class Test {
    public static void main(String[] args) {
        Number number = new Number();
        Thread t1 = new Thread() {
            @Override
            public void run() {
                number.a();
            }
        };
        Thread t2 = new Thread() {
            @Override
            public void run() {
                number.b();
            }
        };

        t1.start();
        t2.start();
    }

}

@Slf4j(topic = "c.Number")
class Number {

    public synchronized void a() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        log.debug("1");
    }

    public synchronized void b() {
        log.debug("2");
    }

}

在情况1的基础上，a方法中sleep一秒，结果可能是：
一秒后打印1、2
或者先打印2，一秒后打印1

2025-10-11 14:20:38.496 [Thread-0] c.Number - 1
2025-10-11 14:20:38.496 [Thread-1] c.Number - 2

2025-10-11 14:22:53.209 [Thread-1] c.Number - 2
2025-10-11 14:22:54.221 [Thread-0] c.Number - 1

3

public class Test {
    public static void main(String[] args) {
        Number number = new Number();
        Thread t1 = new Thread() {
            @Override
            public void run() {
                number.a();
            }
        };
        Thread t2 = new Thread() {
            @Override
            public void run() {
                number.b();
            }
        };

        Thread t3 = new Thread() {
            @Override
            public void run() {
                number.c();
            }
        };

        t1.start();
        t2.start();
        t3.start();


    }

}

@Slf4j(topic = "c.Number")
class Number {

    public synchronized void a() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        log.debug("1");
    }

    public synchronized void b() {
        log.debug("2");
    }

    public void c() {
        log.debug("3");
    }

}

在情况2的基础上，加了个c方法，没有synchronized。
线程在调用c方法的时候不需要获得锁，也就没有互斥效果。
3一定比1先打印，至于2，取决于cpu的调度。

结果可能是：
3、1秒后1、2
3、2、1秒后1
2、3、1秒后1

2025-10-11 14:43:59.073 [Thread-2] c.Number - 3
2025-10-11 14:44:00.082 [Thread-0] c.Number - 1
2025-10-11 14:44:00.082 [Thread-1] c.Number - 2

2025-10-11 14:44:51.578 [Thread-1] c.Number - 2
2025-10-11 14:44:51.578 [Thread-2] c.Number - 3
2025-10-11 14:44:52.581 [Thread-0] c.Number - 1

2025-10-11 14:49:49.206 [Thread-2] c.Number - 3
2025-10-11 14:49:49.206 [Thread-1] c.Number - 2
2025-10-11 14:49:50.214 [Thread-0] c.Number - 1

4

public class Test {
    public static void main(String[] args) {
        Number n1 = new Number();
        Number n2 = new Number();
        Thread t1 = new Thread() {
            @Override
            public void run() {
                n1.a();
            }
        };
        Thread t2 = new Thread() {
            @Override
            public void run() {
                n2.b();
            }
        };

        t1.start();
        t2.start();


    }

}

@Slf4j(topic = "c.Number")
class Number {

    public synchronized void a() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        log.debug("1");
    }

    public synchronized void b() {
        log.debug("2");
    }

}

这种情况下，线程1和线程2锁住的是不同的对象，相当于没有锁，所以一定是先打印2，1秒后打印1。

2025-10-11 14:51:08.810 [Thread-1] c.Number - 2
2025-10-11 14:51:09.818 [Thread-0] c.Number - 1

5

public class Test {
    public static void main(String[] args) {
        Number n1 = new Number();
        Thread t1 = new Thread() {
            @Override
            public void run() {
                n1.a();
            }
        };
        Thread t2 = new Thread() {
            @Override
            public void run() {
                n1.b();
            }
        };

        t1.start();
        t2.start();


    }

}

@Slf4j(topic = "c.Number")
class Number {

    public static synchronized void a() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        log.debug("1");
    }

    public synchronized void b() {
        log.debug("2");
    }

}

a方法变为静态方法，锁住的是类对象，b方法还是实例方法，锁住的是当前对象，线程1和线程2锁住的是不同的对象，相当于没有锁，所以一定是先打印2，1秒后打印1。

2025-10-11 14:56:48.641 [Thread-1] c.Number - 2
2025-10-11 14:56:49.646 [Thread-0] c.Number - 1

6

public class Test {
    public static void main(String[] args) {
        Number n1 = new Number();
        Thread t1 = new Thread() {
            @Override
            public void run() {
                n1.a();
            }
        };
        Thread t2 = new Thread() {
            @Override
            public void run() {
                n1.b();
            }
        };

        t1.start();
        t2.start();


    }

}

@Slf4j(topic = "c.Number")
class Number {

    public static synchronized void a() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        log.debug("1");
    }

    public static synchronized void b() {
        log.debug("2");
    }

}

a和b都是静态方法，也就是锁住的是同一个对象，所以打印顺序取决于CPU调度顺序，和情况1一样。

2025-10-11 15:00:22.546 [Thread-1] c.Number - 2
2025-10-11 15:00:23.547 [Thread-0] c.Number - 1

2025-10-11 15:02:33.079 [Thread-0] c.Number - 1
2025-10-11 15:02:33.083 [Thread-1] c.Number - 2

7

public class Test {
    public static void main(String[] args) {
        Number n1 = new Number();
        Number n2 = new Number();

        Thread t1 = new Thread() {
            @Override
            public void run() {
                n1.a();
            }
        };
        Thread t2 = new Thread() {
            @Override
            public void run() {
                n2.b();
            }
        };

        t1.start();
        t2.start();


    }

}

@Slf4j(topic = "c.Number")
class Number {

    public static synchronized void a() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        log.debug("1");
    }

    public synchronized void b() {
        log.debug("2");
    }

}

锁住不同对象，没有互斥，一定是先2，1秒后1。

2025-10-11 15:04:10.898 [Thread-1] c.Number - 2
2025-10-11 15:04:11.918 [Thread-0] c.Number - 1

8

public class Test {
    public static void main(String[] args) {
        Number n1 = new Number();
        Number n2 = new Number();

        Thread t1 = new Thread() {
            @Override
            public void run() {
                n1.a();
            }
        };
        Thread t2 = new Thread() {
            @Override
            public void run() {
                n2.b();
            }
        };

        t1.start();
        t2.start();


    }

}

@Slf4j(topic = "c.Number")
class Number {

    public static synchronized void a() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        log.debug("1");
    }

    public static synchronized void b() {
        log.debug("2");
    }

}

a和b都是静态方法，锁住的都是类对象，虽然创建了不同的实例对象调用方法，但是锁住的是同一个对象。结果还是取决于CPU先调度谁。

2025-10-11 15:06:57.817 [Thread-1] c.Number - 2
2025-10-11 15:06:58.832 [Thread-0] c.Number - 1

2025-10-11 15:09:30.331 [Thread-0] c.Number - 1
2025-10-11 15:09:30.331 [Thread-1] c.Number - 2

AI编程社区

汇聚全球AI编程工具，助力开发者即刻编程。

更多推荐

码道 · 寻艺——从零构建“非遗交互式对话平台“的完整实践

AI编程社区

码道：用 Python + FastAPI 快速构建一个学生信息管理接口：从零到 Swagger 在线文档

在日常开发和教学中，我们经常需要一套简单、可控、能快速上手的后端接口来演示"前后端分离"、练习 Restful API 设计，或者作为前端联调的 Mock 服务。传统做法往往是搭一套完整的 Web 工程：配置数据库、编写 DAO、引入 ORM、做请求分发……一套流程下来，光环境搭建就要花去不少时间，对于想快速验证想法、或者刚入门 API 开发的同学来说，显得过于沉重。

AI编程社区

码道：从零构建学生信息管理系统 API：FastAPI 内存版 CRUD 项目全解析

FastAPI 的强大，很大程度上来自 Pydantic 的校验能力。我们写下类型声明，FastAPI 在运行时自动把它变成边界检查器。name：字符串，长度限制 1 到 50；age：整数，限制在 6 到 120 之间（ge大于等于、le小于等于）；gender：字符串，用正则限定只能是"男"“女”“其他”；email：邮箱格式字符串；grade与major：可选字段，代表班级和专业方向。