【线程 锁】synchronized所有用法汇总(包含this语法)

已于 2022-08-22 20:52:48 修改
阅读量2k 收藏 24
点赞数 6
分类专栏： Java 文章标签： synchronized 场景 全部 汇总
于 2020-11-03 22:35:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_45406092/article/details/109473860
版权

文章目录

1. synchronized的用法

在java代码中使用synchronized可是使用在代码块和方法中，根据Synchronized用的位置可以有这些使用场景：
在这里插入图片描述

如图，synchronized可以用在方法上也可以使用在代码块中，其中方法是实例方法和静态方法分别锁的是该类的实例对象和该类的对象。而使用在代码块中也可以分为三种，具体的可以看上面的表格。

2. synchronized作用于实例方法

模板：

public synchronized void method{
}

2.1 多个线程访问同一个对象的同一个synchronized方法

每个实例对应一个lock，线程获得该含有synchronized方法的实例的锁才可以执行，否则阻塞。方法一旦执行，则一直到方法返回才可以释放锁。此后被阻塞的线程才能获得该锁。

对于一个实例，其声明为synchronized的方法显然只有一个能处于执行状态。从而避免了类访问变量的冲突。

下面我们来看个例子，创建一个ObjectLock的实例，被2个线性t1和t2同时调用：

public class ObjectLock {
    private int value; // 成员属性

    public synchronized void increment() { // synchronized修饰实例方法
        System.out.println(Thread.currentThread().getName() + " 开始执行");

        for (int j = 0; j < 100; j++) {
            try {
                // 增加执行时间总时间，保证多个线程周期重叠，避免执行过快，比如B线程尚未开始，A线程已经结束
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            value++; // 递增+1
        }
        System.out.println(Thread.currentThread().getName() + " 执行完毕");

    }

    public int getValue() {
        return value;
    }

}



public class SynchronizedTest implements Runnable {
    ObjectLock lock = new ObjectLock();

    public SynchronizedTest(ObjectLock lock) {

        this.lock = lock;
    }

    @Override
    public void run() {
        this.lock.increment();

    }

    public static void main(String[] args) throws InterruptedException {
        ObjectLock lock = new ObjectLock(); // 创建一个实例对象
        Thread t1 = new Thread(new SynchronizedTest(lock)); // 线程12引用lock实例
        Thread t2 = new Thread(new SynchronizedTest(lock)); // 线程t2引用lock实例
        t1.start();
        t2.start();

        t1.join(); // 保证t1线程执行结束，再执行main线程的System.out.println
        t2.join(); // 保证t2线程执行结束，再执行main线程的System.out.println
        System.out.println(lock.getValue());
    }

}

执行结果：

Thread-0 开始执行
Thread-0 执行完毕
Thread-1 开始执行    //说明Thread-1是在Thread-0执行完后才执行的
Thread-1 执行完毕
200

分析：实例对象lock只有一把锁 ，Thread-0先拿到锁，此时Thread-1就只能阻塞等待，直至Thread-0执行完，释放锁后，Thread-1才能拿到锁并执行。

2.2 多个线程访问同一个对象的不同的synchronized方法

此外，如果实例对象有多个synchronized方法，则只要一个线程访问了任何一个synchronized方法，其他线程不能同时访问任何一个该对象的synchronized方法(synchronized作用于对象，且每个对象只有一个锁)。

public class ObjectLock2 {
    public synchronized void method1() {  //method1被synchronized 修饰
        System.out.println("Method 1 start");
        try {
            System.out.println("Method 1 execute");
            Thread.sleep(3000);  //保证多个线程周期重叠
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Method 1 end");
    }

    public synchronized void method2() {   //method2被synchronized 修饰
        System.out.println("Method 2 start");
        try {
            System.out.println("Method 2 execute");
            Thread.sleep(1000);   //保证多个线程周期重叠
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Method 2 end");
    }

}


public class SynchronizedTest2 {

    public static void main(String[] args) throws InterruptedException {
        ObjectLock2 lock = new ObjectLock2(); // 创建一个实例对象
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 线程1引用lock实例
                lock.method1();
            }
        }

        );
        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                // 线程t2引用lock实例
                lock.method2();
            }
        });

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

    }
}

执行结果：

Method 1 start
Method 1 execute
Method 1 end
Method 2 start    //等待method1调用完后，才轮到method2被调用
Method 2 execute
Method 2 end

分析：可以看出当t1持有lock实例上的锁，其他线程t2来访问synchronized修饰的其他方法时需要等待线程t1先把锁释放，method1和method2上的锁是同一个锁。

2.3 一个线程获取了该对象的锁之后，其他线程来访问其他非synchronized实例方法

任意线程任意情况下（不管是否持有锁）都可以访问非synchronized方法

public class ObjectLock3 {
    public synchronized void method1() {    //被synchronized 修饰
        System.out.println("Method 1 start");
        try {
            System.out.println("Method 1 execute");
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Method 1 end");
    }

    public void method2() {     // !!! 未synchronized 修饰
        System.out.println("Method 2 start");
        try {
            System.out.println("Method 2 execute");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Method 2 end");
    }

}


public class SynchronizedTest3 {
    public static void main(String[] args) {
        ObjectLock3 lock = new ObjectLock3(); // 创建一个实例对象
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 线程1引用lock实例
                lock.method1();
            }
        }

        );
        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                // 线程t2引用lock实例

                lock.method2();
            }
        });

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

结果：

Method 1 start
Method 1 execute
Method 2 start   //method2和method1同时被调用
Method 2 execute
Method 2 end
Method 1 end

分析：t1线程持有锁，在同一时刻，t2访问非 synchronized 方法，是可以的。

2.4 当多个线程作用于不同的实例对象

不同的对象，拥有不同的锁，因此多个线程作用于不同实例对象时，是可以同时进行的

public class ObjectLock4 {
    public synchronized void method1() {   //仅有一个synchronized 方法
        System.out.println(Thread.currentThread().getName() + " Method 1 start");
        try {
            System.out.println(Thread.currentThread().getName() + " Method 1 execute");
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " Method 1 end");
    }

}


public class SynchronizedTest4 {
    public static void main(String[] args) {
        ObjectLock4 lock = new ObjectLock4(); // 创建一个实例对象
        ObjectLock4 lock2 = new ObjectLock4(); // 创建一个实例对象
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 线程1引用lock实例
                lock.method1();
            }
        }

        );
        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                // 线程t2引用lock2实例，注意和线程t1引用的不是不同实例

                lock2.method1();
            }
        });

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

执行结果：

Thread-1 Method 1 start
Thread-0 Method 1 start   //Thread-0执行时，Thread-1也在执行
Thread-1 Method 1 execute
Thread-0 Method 1 execute
Thread-1 Method 1 end
Thread-0 Method 1 end

分析：线程t1引用lock实例，持有lock1上的锁，线程t2引用lock2实例，持有lock2实例上的锁，两个线程引用的是不同的实例，持有的是不同的锁，虽然方法名称都相同，但是可以同时调用。

3. synchronized作用于静态方法

synchronized修饰的静态方法，即使是不同的实例，但是只存在一个锁，一旦被持有，就会排斥其他的线程。

public class ObjectLock5 {
    public static synchronized void method1() {  //static方法，且是synchronized 修饰
        System.out.println(Thread.currentThread().getName() + " Method 1 start");
        try {
            System.out.println(Thread.currentThread().getName() + " Method 1 execute");
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " Method 1 end");
    }

}


public class SynchronizedTest5 {
    public static void main(String[] args) {
        ObjectLock5 lock = new ObjectLock5(); // 创建一个实例对象 lock
        ObjectLock5 lock2 = new ObjectLock5(); // 创建一个实例对象 lock2
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 线程1引用lock实例
                ObjectLock5.method1();
            }
        }

        );
        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                // 线程t2引用lock2实例

                lock2.method1();
            }
        });

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

执行结果：

Thread-0 Method 1 start
Thread-0 Method 1 execute
Thread-0 Method 1 end
Thread-1 Method 1 start   //阻塞等待Thread-0释放锁
Thread-1 Method 1 execute
Thread-1 Method 1 end

分析：虽然线程t1和t2引用不同的对象，但是由于是静态的方法，全局就一个锁，一旦t1持有锁，t2就只能等待。

4. Synchronized作用于代码块

synchronized关键字用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。

代码块中有种不同的场景，我们一次来看下

4.1 作用在对象实例上

4.1.1 作用在对象实例上例子

该对象实例拥有一个锁，谁拿到这个锁谁就可以运行它所控制的那段代码。

class Foo implements Runnable {
     private Object lock = new Object(); // instance变量    
     Public void methodA() {      
       synchronized(lock) { 
          dosomething1();
          dosomething2();
       }
    }
 }

如果有2个线程A和B，A先持有锁，则A拥有执行该代码块的权限，如果B也想尝试该代码，则会阻塞，直至A执行完 dosomething2()后释放锁，B才能获取锁。

public class ObjectLock6 {   //锁对象
}

public class SynchronizedTest6 {

    ObjectLock6 lock;      //lock实例

    public SynchronizedTest6(ObjectLock6 lock) {
        this.lock = lock;
    }

    public void method() {    //方法本身没加锁
        synchronized (lock) {   //在代码块中，对lock实例加锁
            System.out.println(Thread.currentThread().getName() + " Method  start");
            try {
                System.out.println(Thread.currentThread().getName() + " Method  execute");
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " Method  end");
        }

    }

    public static void main(String[] args) {
        ObjectLock6 lock = new ObjectLock6();
        SynchronizedTest6 test = new SynchronizedTest6(lock);

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 线程1引用SynchronizedTest6 实例的method()
                test.method();
            }
        }

        );
        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                // 线程t2也引用SynchronizedTest6 实例的method()
                test.method();
            }
        });

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

执行结果：

Thread-0 Method  start
Thread-0 Method  execute
Thread-0 Method  end
Thread-1 Method  start   //t1是在t0执行完代码块，并释放或后才执行
Thread-1 Method  execute
Thread-1 Method  end

分析：2个线程t1和t2同时调用SynchronizedTest6 的method方法，该方法没加锁，但是在代码块中加锁了，效果显示加锁的效果，t1是在t0执行完代码块，并释放或后才执行。

4.1.2 作用在对象实例上时，锁住了谁？

此时有个一疑问，锁是在SynchronizedTest6实例test 上还是在ObjectLock6实例lock上?
答案：锁是在lock上。

在这里插入图片描述

我们来验证下：

public class ObjectLock7 {
    public synchronized void method1() { // 加锁的方法
        System.out.println(Thread.currentThread().getName() + " Method 1 start");
        try {            
            Thread.sleep(3000); // sleep 3s
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " Method 1 end");
    }

}


public class SynchronizedTest7 {

    ObjectLock7 lock;

    public SynchronizedTest7(ObjectLock7 lock) {
        this.lock = lock;
    }

    public void method() {
        synchronized (lock) { // 代码块加锁，该锁在lock上，不是SynchronizedTest7上
            System.out.println(Thread.currentThread().getName() + " Method  start");
            try {
                Thread.sleep(3000); // sleep 3s
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " Method  end");
        }

    }

    public synchronized void anotherMethod() { // 加锁了，锁在SynchronizedTest7实例上
        System.out.println(Thread.currentThread().getName() + " anotherMethod  start");
    }

    public static void main(String[] args) {
        ObjectLock7 lock = new ObjectLock7();
        SynchronizedTest7 test = new SynchronizedTest7(lock);

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 线程1引用SynchronizedTest7的实例test的method()，代码块中加锁，锁在lock对象上
                test.method();
            }
        }

        );
        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                // 线程t2引用lock实例的方法，该方法加锁了

                lock.method1();
            }
        });

        Thread t3 = new Thread(new Runnable() {

            @Override
            public void run() {
                // 线程t3引用SynchronizedTest7的实例test的anotherMethod()，是个加锁的方法

                test.anotherMethod();
            }
        });

        t1.setName("Thread1");
        t1.start();
        t2.setName("Thread2");
        t2.start();

        try {
            Thread.sleep(1000); // sleep 1s，确保t2先执行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t3.setName("Thread3");
        t3.start();

    }
}

执行结果：

Thread1 Method  start
Thread3 anotherMethod  start  //t3打印夹在t1过程中，说明二者不冲突，锁不在SynchronizedTest7上
Thread1 Method  end
Thread2 Method 1 start   //t1执行完后，t2才会打印
Thread2 Method 1 end

我们创建了3个线程，t1和t3都是访问SynchronizedTest7实例的不同方法，结果显示二者可以同时执行，说明没有锁住SynchronizedTest7自身的方法；

t1调用的方法在代码块中对lock实例加锁，此时t2尝试访问lock实例的另一个加锁方法，结果方法二者存在先后顺序，t2等t1执行完才能获取锁执行，说明锁在lock实例上。

4.1.3 最佳实践，最小的锁对象
class Foo implements Runnable {
     private byte[] lock = new byte[0]; // instance变量    
     Public void methodA() {      
       synchronized(lock) { //… }
    }
 }

注：零长度的byte数组对象创建起来将比任何对象都经济――查看编译后的字节码：生成零长度的byte[]对象只需3条操作码，而Object lock = new Object()则需要7行操作码

4.2 作用在this上

this 代表当前实例：

public void method {
   synchronized(this) {
    for (int j = 0; j < 100; j++) {
		i++;
    }
}

等价于下面的模板，本质是在当前类的实例的方法上加锁：

public synchronized void method {
    for (int j = 0; j < 100; j++) {
		i++;
    }
}

例子就不单独列举了，简单来说，与SynchronizedTest7改造一下，把SynchronizedTest7的method()替换为：

 public void method() {
        synchronized (this) { // 代码块加锁，该锁在SynchronizedTest7实例上
         ...
        }

    }

执行结果：

//已经剔除了t2的相关信息，因为和lock实例无关了
Thread1 Method  start

Thread1 Method  end
Thread3 anotherMethod  start    //t3此时依赖t1了，因为锁在SynchronizedTest7实例上了

4.3 作用在 .class 上

public void method() {
  synchronized(AccountingSync.class) {
    for (int j = 0; j < 100; j++) {
        i++;
    }
}

等价于下面的模板，作用在所有类的静态方法上的锁：

public static synchronized void method() {
    for (int j = 0; j < 100; j++) {
        i++;
    }
}

例子就不单独列举了。





参考：
Synchronized的使用参考其例子

让你彻底理解Synchronized 参考其场景图

云川之下
关注
  • 6
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Synchronized使用的各种案例
BorisCao的博客
04-14 1137
synchronized: 锁定对象(在堆内存中)，即保证了原子性又保证了可见性 实例一、sycnchronized锁定某个对象 //hotspot是这样实现的，在一个对象的头64位，拿出2位来记录这个对象是否被锁定（mark word） private int count = 10; Object o = new Object(); public static void m...
Java使用synchronized修饰方法来同步线程的实例演示
09-02
所有调用该方法的线程都需要获取对象锁才能执行。 - **synchronized代码块**：使用`synchronized(obj){...}`结构，其中obj是需要锁定的对象，这将同步代码块内的代码。 3. **示例分析** 在提供的示例中，我们有两...
java中synchronized的使用
10-16
java中synchronized的使用,java中的锁锁的到底是什么？是括号里的代码块吗？肯定不是的；
synchronized 的 8 种用法，你会几种？
Java技术栈，分享最主流的Java技术
08-28 686
点击关注公众号，Java干货及时送达国内最强微服务框架，没有之一！几乎覆盖 Spring Boot 所有操作！2023全新 Java面试题（2500＋）简介本文将介绍8种同步方法的访问场景，我们来看看这8种情况下，多线程访问同步方法是否还是线程安全的。这些场景是多线程编程中经常遇到的，而且也是面试时高频被问到的问题，所以不管是理论还是实践，这些都是多线程场景必须要掌握的场景。八种使用场景...
synchronized用法详解
qq_43842093的博客
03-03 1947
synchronized 是 Java 中的关键字，是一种同步锁。主要应用于多线程环境下保证线程的安全性。A. 无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。B. 每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。C. 实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。
线程锁synchronized (this)锁住的是对象还是方法
u014191624的博客
09-15 503
​​​​​​​ 测试类： package com.koow.kkwwo.test; public class MyRunnable extends Thread { public static void main(String[] args) { Thread ta = new MyRunnable(); Thread tb = new MyRunnable(); ta.start(); tb.start(); } public void run() { F
Runnable接口实现线程、synchronized块锁代码详解
DrMaker的博客
07-17 606
线程： 1、利用Runnable接口实现线程 · 这种方式扩展性较强，可以实现一个接口，还可以再去继承其他类，省去了单继承的弊端；但这种方式也要重写run方法，实现该接口后与Thread类一起使用。 · 实现了Runnable接口的类的对象不是线程对象，只是为线程对象提供入口方法（run()方法）。 · 创建了实现Runnable接口的类的对象后，可以直接new一个线程对象（Thread t = new Thread(mt)）（有自己的run方法，只是不用），注意要调用Thread类有参的构造方法，将实现了
聊聊Java关键字synchronized
Hi，我是sharkchili，CSDN Java领域博客专家，开源项目JavaGuide维护人员，我想写一些有意思的东西，希望对你有帮助。
02-13 4009
具体例子，某段线程得到锁Test.class之后，执行临界代码逻辑，可能会先执行变量b初始化的逻辑，在执行a变量初始化的逻辑，但是最终结果都会执行a+b的逻辑。每个线程使用synchronized获得锁操作临界资源时，首先需要获取临界资源的值，为了保证临界资源的值是最新的，JMM模型规定线程必须将本地工作内存清空，到共享内存中加载最新的进行操作。正是由于锁互斥的失败，导致两个线程同时到临界区域加载资源，获得的count都是0，经过自增后都是1，导致数据少了1。
Java线程安全和锁Synchronized知识点详解
08-25
Java线程安全和锁Synchronized知识点详解 ...Java线程安全和锁Synchronized知识点详解是Java开发中非常重要的一部分，正确地使用synchronized关键字可以确保多线程环境下的数据安全，避免数据不一致或数据污染等问题。
java多线程编程之使用Synchronized块同步方法
09-04
这里，`staticMethod`是同步的，所有线程在调用时都会等待锁的释放。 在内部类（InnerClass）中，如果需要与外部类的非静态方法同步，可以使用`OuterClass.this`作为同步锁，例如： ```java public class Sync...
多线程的使用与线程锁的两种实现
05-08
了解更多访问https://blog.csdn.net/qq_37651267/article/details/89978759
java多线程编程之使用Synchronized关键字同步类方法
09-04
如果要使`method()`方法在所有`Test`实例间同步，你需要确保所有线程使用的都是同一个`Test`实例。 此外，`synchronized`关键字也可以用于同步静态方法，这意味着所有类的实例共享同一把锁，无论实例化多少个对象，...
Java多线程程序中synchronized修饰方法的使用实例
09-02
所有尝试访问该同步方法的其他线程会被阻塞，直到持有锁的线程完成执行并释放锁。例如： ```java public class SynchronizedTest1 extends Thread { private synchronized void testSynchronizedMethod() { // .....
使用synchronized的方法和作用
Sourcs的博客
08-09 2601
转自http://blog.csdn.net/soartju/article/details/2840491 在java编程思想中对synchronized的一点解释: 1、synchronized关键字的作用域有二种： 1）是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchr
synchronized用法（简单介绍）
weixin_43888267的博客
04-29 538
简单介绍 synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种： 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 修饰一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象； 修饰...
synchronized用法
yuanleiming的博客
08-28 360
synchronized是Java中的关键字，是一种同步锁。 四种用法： 1，修饰一个代码块 当synchronized修饰代码块的时候，表示线程在执行的时候会将synchronized括号中的对象上锁，这个对象可以是任意类的对象，也可以使用this关键字。作用的范围是大括号{}括起来的代码，一个线程访问一个对象中的synchronized(变量)同步代码块时，其他试图访问该对象的线程将被阻
Java 多线程5：synchronized 关键字用法（修饰类，方法，静态方法，代码块）
hutongling的博客
04-07 1824
在 多线程生成的原因（Java内存模型与i++操作解析） 中，介绍了Java的内存模型，从而可能导致的多线程问题。synchronized就是避免这个问题的解决方法之一。除了 synchronized 的方式，还有 lock，condition，volatile，threadlocal，atomicInteger，cas等方式。synchronized 用法它的修饰对象有几种：修饰一个类，其作用的范
Synchronized 详解
ant的博客
04-12 2681
语法 synchronized(锁对象) // 线程1， 线程2(blocked) { 临界区 } 注意 如果 t1 synchronized(obj1) 而 t2 synchronized(obj2) 会怎样？ 此种方式相当于多个线程持有不同的锁，不会起到保证临界区代码是原子性操作，达不到预期 如果 t1 synchronized(obj) 而 t2 没有加会怎么样？ 此种方式相当于一个线程持有锁一个线程没有锁，不会起到保证临界区代码是原子性操作，达不到预期 方法上的synchronized形式
股票分时图K线图小程序-微信小程序源码.zip
最新发布
06-19
股票分时图K线图小程序-微信小程序源码
线程锁synchronized
09-02
线程锁（synchronized）是一种Java中的同步机制，用于保护共享资源的并发访问。当多个线程尝试同时访问同一个被synchronized关键字标记的代码块时，只有一个线程能够进入该代码块执行，其他线程则被阻塞。 使用synchronized关键字可以实现两种类型的锁：对象锁和类锁。 1. 对象锁：当一个线程进入synchronized代码块时，它会自动获取该代码块所属对象的锁。其他线程必须等待当前线程执行完毕后才能进入该代码块。 例如： ```java public class MyClass { public synchronized void myMethod() { // 代码块 } } ``` 2. 类锁（静态方法锁）：当一个线程进入使用synchronized关键字修饰的静态方法时，它会自动获取该方法所属类的锁。其他线程必须等待当前线程执行完毕后才能进入该静态方法。 例如： ```java public class MyClass { public static synchronized void myStaticMethod() { // 代码块 } } ``` 使用synchronized关键字可以有效地避免多个线程同时访问共享资源导致的数据不一致或者错误。然而，过多地使用synchronized可能会导致性能问题，因此在设计并发程序时需要慎重考虑锁的使用范围和粒度。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值