导航：首页 > 开发技术 >

java中synchronized关键字的3种写法分别是什么

发表于：2025-01-20 作者：千家信息网编辑

千家信息网最后更新 2025年01月20日，java中synchronized关键字的3种写法分别是什么，针对这个问题，这篇文章详细介绍了相对应的分析和解答，希望可以帮助更多想解决这个问题的小伙伴找到更简单易行的方法。预备知识首先，我们得知道在

千家信息网最后更新 2025年01月20日java中synchronized关键字的3种写法分别是什么

java中synchronized关键字的3种写法分别是什么，针对这个问题，这篇文章详细介绍了相对应的分析和解答，希望可以帮助更多想解决这个问题的小伙伴找到更简单易行的方法。

预备知识

首先，我们得知道在java中存在三种变量：

实例变量 ==》存在于堆中
静态变量 ==》存在于方法区中
局部变量 ==》存在于栈中

然后，我们得明白，合适会发生高并发不安全

条件1：多线程并发。
条件2：有共享数据。
条件3：共享数据有修改的行为。

具体不安全案例请参考如下这篇文章：java线程安全问题详解

在上面这篇文章银行取钱案例中，我们解决线程安全问题的方法是加了一个 synchronized 关键字。下面我们就详细介绍一下 synchronized 的三种写法，分别解决什么问题！！！

写法一：修饰代码块

package ThreadSafa; public class Test {    public static void main(String[] args) {        TestAccount ta1 = new TestAccount();        ta1.setNum(10);         //共用一个账户对象        TestThread t1 = new TestThread(ta1);        TestThread t2 = new TestThread(ta1);        t1.start();        t2.start();    }} class TestThread extends Thread {     private TestAccount mAccount;     public TestThread(TestAccount mAccount) {        this.mAccount = mAccount;    }     @Override    public void run() {        mAccount.updateNum(1);    }} class TestAccount {    private double num;     public double getNum() {        return num;    }     public void setNum(double num) {        this.num = num;    }     public void updateNum(int n) {        synchronized (this) {            try {                Thread.sleep(1000);            } catch (InterruptedException e) {                e.printStackTrace();            }            setNum(getNum() - n);        }        System.out.println(getNum());    }}

运行结果

写法二：修饰方法

package ThreadSafa; public class Test {    public static void main(String[] args) {        TestAccount ta1 = new TestAccount();        ta1.setNum(10);         TestThread t1 = new TestThread(ta1);        TestThread t2 = new TestThread(ta1);        t1.start();        t2.start();    }} class TestThread extends Thread {     private TestAccount mAccount;     public TestThread(TestAccount mAccount) {        this.mAccount = mAccount;    }     @Override    public void run() {        mAccount.updateNum(1);    }} class TestAccount {    private double num;     public double getNum() {        return num;    }     public void setNum(double num) {        this.num = num;    }     public synchronized void updateNum(int n) {        try {            Thread.sleep(1000);        } catch (InterruptedException e) {            e.printStackTrace();        }        setNum(getNum() - n);        System.out.println(getNum());    }}

运行结果

总结

可以看到，前面这两种写法其实是等价的，什么意思呢？就是当你用 synchronized 修饰共享对象 this 的时候你就可以吧 synchronized 提到方法前面，但是我们一般不会这么干，因为扩大 synchronized 修饰的代码范围会使代码运行效率降低。

同时，前面两种方法都是为了解决实例变量线程安全问题而诞生的，对于静态变量我们怎么处理呢？请看写法三：

写法三：修饰静态方法

package ThreadSafa; public class Test {    public static void main(String[] args) {        TestAccount ta1 = new TestAccount();        TestAccount ta2 = new TestAccount();         TestThread t1 = new TestThread(ta1);        TestThread t2 = new TestThread(ta2);        t1.start();        t2.start();    }} class TestThread extends Thread {     private TestAccount mAccount;     public TestThread(TestAccount mAccount) {        this.mAccount = mAccount;    }     @Override    public void run() {        mAccount.updateCount(1);    }} class TestAccount {    private double num;    public static double count = 10;     public double getNum() {        return num;    }     public void setNum(double num) {        this.num = num;    }     public synchronized void updateNum(int n) {        try {            Thread.sleep(1000);        } catch (InterruptedException e) {            e.printStackTrace();        }        setNum(getNum() - n);        System.out.println(getNum());    }     public synchronized static void updateCount(int n) {        try {            Thread.sleep(1000);        } catch (InterruptedException e) {            e.printStackTrace();        }        count -= n;        System.out.println(count);    }}

运行结果展示

可以看到，在静态方法上加 synchronized 之后，他锁的是这个类，尽管两个账户对象不一样，但是，加了 synchronized 会保证他们排队执行，也就是保证了线程安全。

synchronized原理

Synchronized是通过对象内部的一个叫做监视器锁（monitor）来实现的。但是监视器锁本质又是依赖于底层的操作系统的互斥锁（Mutex Lock）来实现的。而操作系统实现线程之间的切换这就需要从用户态转换到核心态，这个成本非常高，状态之间的转换需要相对比较长的时间，这就是为什么Synchronized效率低的原因。这种依赖于操作系统互斥锁（Mutex Lock）所实现的锁我们称之为"重量级锁"。