synchronized锁

最新推荐文章于 2024-04-04 17:59:43 发布

maercecd

最新推荐文章于 2024-04-04 17:59:43 发布

阅读量1.4k

点赞数 1

CC 4.0 BY-SA版权

分类专栏： Java 文章标签： synchronize Java锁同步

本文链接：https://blog.youkuaiyun.com/yun_ld/article/details/93536797

Java 专栏收录该内容

35 篇文章

订阅专栏

本文深入解析Java中的synchronized关键字，探讨其在同步代码块、非静态和静态同步方法中的应用，以及如何通过加锁机制解决多线程环境下的资源竞争问题。

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

synchronized关键字是Java锁的一种方式。被synchronized修饰的方法或者代码块称为同步方法或同步代码块，synchronized可以保证方法或代码块在运行时，同一时刻只有一个线程可以执行同步方法或者同步代码块（互斥性），同时它还保证了共享变量的内存可见性。

Java的每一个对象都可以作为一个锁，不管是实例对象还是class对象。

synchronized根据使用的方式不同分为如下三种情况：

1、同步代码块，锁是括号中的对象。

package test;

public class SynchronizedBlock {

    // 定义一个锁，因为任何对象都可以作为锁，所以这里可以直接用Object对象定义锁，
    // 变量名可根据实际需要自行定义。
    public final Object obj = new Object();

    public void syncBlock() {
        // 同步代码块，锁对象是上面定义的obj对象
        synchronized (obj) {
            System.out.println("synchronized block");
        }
    }
}

2、非静态同步方法，锁是当前实例对象。

package test;

public class SynchronizedMethod {
    // 非静态同步方法，锁对象是当前实例
    public synchronized void syncMethod() {
        System.out.println("synchronized method");
    }
}

3、静态同步方法，锁的是class对象。

package test;

public class SynchronizedStaticMethod {
    // 静态同步方法，锁对象是当前类的class，也即SynchronizedStaticMethod.class
    // 与普通同步方法的区别就是static修饰符
    public static synchronized void syncStaticMethod() {
        System.out.println("synchronized method");
    }
}

同步代码块根据括号中锁对象的不同也分为两种，与非静态同步方法和静态同步方法也有以下关联：

1、同步代码块的锁对象是当前实例时

package test;

public class SynchronizedMethod {
    // 非静态同步方法，锁对象是当前实例
    public synchronized void syncMethod() {
        System.out.println("synchronized method");
    }

    public void syncBlock() {
        // 同步代码块，因为括号中是this，所以锁对象是当前对象实例
        synchronized (this) {
            System.out.println("synchronized block");
        }
    }

    public static void main(String[] args) {
        // 初始化一个实例
        SynchronizedMethod synchronizedMethod = new SynchronizedMethod();

        // 启用两个线程进行方法的调用
        // 因为syncMethod()和syncBlock()的锁对象都是synchronizedMethod实例，
        // 所以同时只能有一个方法能成功执行
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronizedMethod.syncMethod();
            }
        }, "thread-1").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronizedMethod.syncBlock();
            }
        }, "thread-2").start();
    }
}

2、同步代码块的锁对象是class对象时

package test;

public class SynchronizedStaticMethod {
    // 静态同步方法，锁对象是当前类的class，SynchronizedStaticMethod.class
    // 与普通同步方法的区别就是static修饰符
    public static synchronized void syncStaticMethod() {
        System.out.println("synchronized method");
    }

    public void syncStaticBlock() {
        // 同步代码块，因为括号中是SynchronizedStaticMethod.class，所以
        // 锁对象是SynchronizedStaticMethod.class对象
        synchronized (SynchronizedStaticMethod.class) {
            System.out.println("synchronized block");
        }
    }

    public static void main(String[] args) {
        // 初始化一个实例
        SynchronizedStaticMethod synchronizedStaticMethod = new SynchronizedStaticMethod();

        // 启用两个线程进行方法的调用
        // 因为syncStaticBlock()和syncStaticMethod()的锁对象都是
        // SynchronizedStaticMethod.class对象，所以同时只能有一个方法能成功执行
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronizedStaticMethod.syncStaticBlock();
            }
        }, "thread-1").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                SynchronizedStaticMethod.syncStaticMethod();
            }
        }, "thread-2").start();
    }
}

为什么要使用synchronized加锁，加锁有什么用？

如下代码是在不使用synchronized的情况下：

package test;

public class SynchronizedTest {

    public int m = 0;
    public int n = 0;

    // 定义一个锁，因为任何对象都可以作为锁，所以这里可以直接用Object对象定义锁。
    public final Object lock = new Object();

    // 普通的方法(未加synchronized关键字)
    public void printNumber() {
        System.out.println(Thread.currentThread().getName() + " :" + n++);
    }

    public static void main(String[] args) {
        // 初始化一个实例
        SynchronizedTest synchronizedTest = new SynchronizedTest();

        // 启用两个线程进行方法的调用
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    synchronizedTest.printNumber();
                }
            }
        }, "thread-1").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    synchronizedTest.printNumber();
                }
            }
        }, "thread-2").start();
    }
}

可能会出现如下的结果（并非按照0-19的顺序依次打印）（当然执行多次得到的结果是不一样的，也可能会出现按照0-19的顺序依次打印，但做不到每次都按照0-19的顺序依次打印）

thread-1 :0
thread-2 :0    // 与预期的结果不一样
thread-1 :1
thread-2 :2
thread-1 :3
thread-2 :4
thread-1 :5
thread-2 :6
thread-2 :8
thread-2 :9
thread-2 :10
thread-2 :11
thread-2 :12
thread-2 :13
thread-1 :7    // 与预期的结果不一样
thread-1 :14
thread-1 :15
thread-1 :16
thread-1 :17
thread-1 :18

如下是在使用synchronized同步代码块的情况下：

package test;

public class SynchronizedTest {

    public int m = 0;
    public int n = 0;

    // 定义一个锁，因为任何对象都可以作为锁，所以这里可以直接用Object对象定义锁。
    public final Object lock = new Object();

    // 该方法中有synchronized同步代码块
    public void syncPrintNumber() {
        // 使用synchronized对代码块加锁，同一时间只能有一个线程执行代码块中的代码
        synchronized (lock) {
            System.out.println(Thread.currentThread().getName() + " :" + m++);
        }
    }

    public static void main(String[] args) {
        // 初始化一个实例
        SynchronizedTest synchronizedTest = new SynchronizedTest();

        // 启用两个线程进行方法的调用
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    synchronizedTest.syncPrintNumber();
                }
            }
        }, "thread-1").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    synchronizedTest.syncPrintNumber();
                }
            }
        }, "thread-2").start();
    }
}

不管执行多少次，得到的结果都如下：（每次都按0-19的顺序依次打印，但线程名并不固定）

thread-1 :0
thread-2 :1
thread-2 :2
thread-2 :3
thread-2 :4
thread-2 :5
thread-2 :6
thread-2 :7
thread-2 :8
thread-2 :9
thread-2 :10
thread-1 :11
thread-1 :12
thread-1 :13
thread-1 :14
thread-1 :15
thread-1 :16
thread-1 :17
thread-1 :18
thread-1 :19

说明在多线程的情况下，对同一个资源进行操作时(这里是指两个线程对同一个SynchronizedTest实例中的值进行操作)，在不使用synchronized锁的情况下，结果是不可预期的；而使用synchronized锁之后，结果就如我们期望的那样，因为同一时间只有一个线程获得锁对象，只有获得锁对象的线程才可以执行同步方法或者同步代码块。