Java syncronized关键字用法详解

最新推荐文章于 2025-07-06 09:50:38 发布

zhao_tuo

最新推荐文章于 2025-07-06 09:50:38 发布

阅读量651

点赞数 2

分类专栏： java 多线程

java 同时被 2 个专栏收录

5 篇文章

订阅专栏

多线程

1 篇文章

订阅专栏

本文详细介绍了Java中的synchronized关键字，包括其两种主要用法：修饰成员方法和语句块，并讨论了使用时需要注意的问题，如锁的自动释放机制、可重入特性及与Lock接口的性能对比。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

synchronized是Java关键字，通过syncronized可以获取一个对象的对象锁。

Java syncronized 用法

synchronized有两种用法

A. 修饰成员方法。

修饰成员方法用法如下。

[public/private/protected] [ static ] synchronized 返回类型 方法名(参数列表) {
    ....
}1
2
3

修饰成员方法时既可以修饰是普通的成员方法，也可以修饰类的静态方法。但不能是类的构造方法。
synchronized修饰成员方法时，放置的位置可以是在static前后，也可以放在访问修饰符的前后，但必须在返回类型前面，不能出现在返回类型后面（当然也不能出现在方法名，参数列表等后面）。

B. 修饰语句块

修饰语句块用法如下。

synchronized(object) {
    ....
}1
2
3

修饰语句块时必须指定锁定的对象object。object必须是已经定义的类的对象，不能是int等基本类型的变量，不能是null（会抛出空指针异常）。

使用 syncronized 的注意事项

Java中每一个对象都有唯一的一个对象锁与之关联。
当synchronized修饰的成员方法或语句块执行完成或执行过程中抛出异常时，会自动释放锁。无需手动释放锁（实际上也没有办法手动释放）。
无论synchronized修饰的是成员方法还是语句块，synchronized锁定的都是对象，而不是某一段代码。

当synchronized修饰非静态成员方法时，锁定的对象是当前调用这个方法的对象，也就是说和synchronized(this)锁定的是同一个对象。查看如下代码，虽然两处synchronized表现形式不同，但是会造成死锁。

private void test() {
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            log("run in thread");
        }
    };
    final Thread thread = new Thread(runnable);
    thread.start();
    synchronized (this) {
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

private synchronized void log (String str){
    Log.i("ccpat", str);
}1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

当synchronized修饰静态成员方法时，锁定的对象是当前调用这个方法的对象对应类的Class类的对象，也就是说和synchronized(类名.class)锁定的是同一个对象。因此，如下代码会造成死锁。

private void test() {
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            log("run in thread");
        }
    };
    final Thread thread = new Thread(runnable);
    thread.start();
    synchronized (this.getClass()) {
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

private synchronized static void log (String str){
    Log.i("ccpat", str);
}1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

Java中一个线程在通过synchronized获取到一个对象的对象锁后会阻塞试图获取该对象锁的其他线程，但不会阻塞当前线程，也就是说synchronized代码块对当前线程来说是可重入的。如下代码可以顺利执行，不会死锁。
```
private void test() {
    synchronized (this) {
        synchronized (this) {
            ...
        }
    }
}1
2
3
4
5
6
7
```
Java使用synchronized同步线程时需要对线程进行阻塞和唤醒，这需要较大的系统开销。从JDK 1.5开始，在java.util.concurrent.locks包种提供了一系列和锁相关的接口和类，例如ReentrantLock（可重入锁），ReentrantReadWriteLock（读写锁）等，通过这些Lock类来实现同步操作相比synchronized开销要小。因此，在JDK 1.5上开发时，如果需要提高效率，可以使用Lock来替代synchronized，但Lock使用上要更复杂一些，也容易出错。从JAVA 6开始，JVM对synchronized的执行做了大量优化，增加了自旋锁，锁消除，锁粗化等机制，大大减少了synchronized实际的执行开销，在性能上和Lock已经相差无几。因此，如果是基于JDK 1.6开发，就没有必要为了提高性能用Lock来替换synchronized了。
为了提高synchronized的效率，减少开销，JVM实现synchronized时使用的是非公平竞争的锁机制，也就是说如果有多个线程在等待同一个对象锁，当这个对象锁被释放后，不保证获取到该对象锁的线程是最先等待的线程。如果想要让线程按照等待的顺序来获取锁，那么就需要使用java.util.concurrent.locks的公平锁。