synchronized(this)锁定的是对象还是方法

本文通过实例探讨了Java中`synchronized(this)`关键字锁住的对象是当前对象。当使用相同对象同步时,确保了线程间的正确顺序执行;反之,若对象不同则导致竞态条件。关键实验展示了同步机制如何影响多线程并发行为。

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

synchronized(this)锁住的到底是对象还是方法?我们来看一个简单的例子:
线程类JavaFunTest 在main方法中创建了两个线程。

public class JavaFunTest extends Thread{

    private Test test;
    public JavaFunTest(Test test) {
        this.test = test;
    }

    @Override
    public void run() {
        test.printThreadName();
    }
}

class Test {

    public void printThreadName() {
        synchronized (this) {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + " , i = " + i);
            }
        }
    }
}

1.首先我们先给两个线程类传入不同测试对象。

 public static void main(String[] args) {
        Test test1 = new Test();
        Test test2 = new Test();
        JavaFunTest javaFunTest1 = new JavaFunTest(test1);
        JavaFunTest javaFunTest2 = new JavaFunTest(test1);
        javaFunTest1.start();
        javaFunTest2.start();
 }

打印结果是:
Thread-1 , i = 0
Thread-1 , i = 1
Thread-0 , i = 0
Thread-1 , i = 2
Thread-0 , i = 1
Thread-1 , i = 3
Thread-0 , i = 2
Thread-1 , i = 4
Thread-0 , i = 3
Thread-1 , i = 5
Thread-0 , i = 4
Thread-1 , i = 6
Thread-0 , i = 5
Thread-1 , i = 7
Thread-0 , i = 6
Thread-1 , i = 8
Thread-0 , i = 7
Thread-1 , i = 9
Thread-0 , i = 8
Thread-0 , i = 9
从结果可以看出 ,线程1并未等待另一个线程执行完,而是互相争夺执行权,谁也没让着谁。
2. 其次我们给两个线程类传入相同的对象。

 public static void main(String[] args) {
        Test test1 = new Test();
        // Test test2 = new Test();
        JavaFunTest javaFunTest1 = new JavaFunTest(test1);
        JavaFunTest javaFunTest2 = new JavaFunTest(test1);
        javaFunTest1.start();
        javaFunTest2.start();
}

再看下执行结果:
Thread-1 , i = 0
Thread-1 , i = 1
Thread-1 , i = 2
Thread-1 , i = 3
Thread-1 , i = 4
Thread-1 , i = 5
Thread-1 , i = 6
Thread-1 , i = 7
Thread-1 , i = 8
Thread-1 , i = 9
Thread-0 , i = 0
Thread-0 , i = 1
Thread-0 , i = 2
Thread-0 , i = 3
Thread-0 , i = 4
Thread-0 , i = 5
Thread-0 , i = 6
Thread-0 , i = 7
Thread-0 , i = 8
Thread-0 , i = 9
从结果来看,线程1执行完,线程0才执行,线程锁发挥作用了。
由此看出,synchronized(this)锁住的是对象。

### Java 中 `synchronized` 锁定对象的区别及用法 #### 一、基本概念 在 Java 中,`synchronized` 是一种用于控制多线程访问共享资源的关键字。它的作用是通过加机制来确保同一时间只有一个线程能执行特定的代码块或方法。 - **对象**:当 `synchronized` 应用于非静态方法或某个对象实例上的同步代码块时,锁定的是调用该方法对象实例[^3]。 - ****:当 `synchronized` 应用于静态方法或整个对象时,锁定的是本身(即 `Class` 对象)。由于每个只有一个 `Class` 实例,因此这种对于所有线程来说都是全局唯一的[^4]。 --- #### 二、具体区别 ##### 1. 锁定目标的不同 - 当 `synchronized` 修改非静态方法时,锁定的目标是调用此方法的具体对象实例。这意味着不同的对象实例之间不会互相影响[^1]。 ```java public class Example { public synchronized void instanceMethod() { // 对象 System.out.println(Thread.currentThread().getName() + " is executing this method."); } } ``` - 当 `synchronized` 修改静态方法时,锁定的目标是的 `Class` 对象。因为一个只有唯一的一个 `Class` 对象,所以无论多少个线程运行此中的静态方法,它们都会被串行化处理[^2]。 ```java public class Example { public static synchronized void staticMethod() { // System.out.println(Thread.currentThread().getName() + " is executing the static method."); } } ``` ##### 2. 并发行为差异 - 使用对象的情况下,多个线程如果操作的是同一个对象,则会按照顺序依次执行;但如果针对不同对象实例的方法调用则可以并发进行。 - 使用时,即使有多个对象实例存在,只要涉及到了相同的静态方法,所有的线程都需要排队等待前一个完成后再继续。 --- #### 三、代码示例说明 以下是分别展示对象的例子: ##### (1) 对象示例 下面展示了如何利用 `synchronized` 来保护单个对象实例的数据一致性。 ```java class Counter { private int count; public synchronized void increment() { // 对象 count++; } public int getCount() { return count; } } // 测试部分 public class Main { public static void main(String[] args) throws InterruptedException { Counter counter = new Counter(); Thread t1 = new Thread(() -> { for(int i=0;i<1000;i++) counter.increment(); }); Thread t2 = new Thread(() -> { for(int i=0;i<1000;i++) counter.increment(); }); t1.start();t2.start(); t1.join();t2.join(); System.out.println(counter.getCount()); // 输出应接近于2000 } } ``` ##### (2) 示例 这里演示了 `synchronized` 静态方法的作用——它会对整个生效而不是单独某几个对象。 ```java class Singleton { private static Singleton instance; private Singleton() {} public static synchronized Singleton getInstance() { // if(instance == null){ instance = new Singleton(); } return instance; } } // 测试部分 public class TestSingleton { public static void main(String[] args) { Singleton s1 = Singleton.getInstance(); Singleton s2 = Singleton.getInstance(); System.out.println(s1 == s2); // true 表明两次获取到的是相同实例 } } ``` --- #### 四、总结 综上所述,`synchronized` 的主要功能在于提供了一种简单的方式来进行线程间的同步协调。其核心要点如下: - 如果应用于普通成员函数,则是对当前对象施加独占权限; - 若应用至静态成员函数,则相当于对整个别进行了约束管理。 这使得开发者可以根据实际需求灵活选择合适的策略以保障程序逻辑的一致性和安全性。 --- ###
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值