Java中synchronized同步锁用法及作用范围

最新推荐文章于 2024-06-13 17:40:21 发布
最新推荐文章于 2024-06-13 17:40:21 发布
阅读量7.5w 收藏 244
点赞数 86
分类专栏： 并发 文章标签： synchronized Java 多线程 同步 对象锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yx0628/article/details/79086511
版权

Java 中的 synchronized 关键字可以在多线程环境下用来作为线程安全的同步锁。本文主要对 synchronized 的作用，以及其有效范围进行讨论。
Java中的对象锁和类锁：java的对象锁和类锁在锁的概念上基本上和内置锁是一致的，但是，两个锁实际是有很大的区别的，对象锁是用于对象实例方法，或者一个对象实例上的，类锁是用于类的静态方法或者一个类的class对象上的。我们知道，类的对象实例可以有很多个，但是每个类只有一个class对象，所以不同对象实例的对象锁是互不干扰的，但是每个类只有一个类锁。但是有一点必须注意的是，其实类锁只是一个概念上的东西，并不是真实存在的，它只是用来帮助我们理解锁定实例方法和静态方法的区别的。

synchronized 关键字主要有以下几种用法：
- 非静态方法的同步；
- 静态方法的同步；
- 代码块。

下面分对象锁和类锁来分别说明 synchronized 用法：

对象锁

非静态方法使用 synchronized 修饰的写法，修饰实例方法时，锁定的是当前对象：

    public synchronized void test(){
        // TODO
    }

代码块使用 synchronized 修饰的写法，使用代码块，如果传入的参数是 this，那么锁定的也是当前的对象：

    public void test(){
        synchronized (this) {
            // TODO
        }
    }

下面通过例子来说明对象锁：
定义一个类，方法如下，将 count 自减，从 5 到 0：

public class TestSynchronized {

    public synchronized void minus() {
        int count = 5;
        for (int i = 0; i < 5; i++) {
            count--;
            System.out.println(Thread.currentThread().getName() + " - " + count);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
            }
        }
    }

}

测试调用方法如下：

public class Run {

    public static void main(String[] args) {

        final TestSynchronized test = new TestSynchronized();

        Thread thread1 = new Thread(new Runnable() {

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

        Thread thread2 = new Thread(new Runnable() {

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

        thread1.start();
        thread2.start();

    }

}

两个线程 thread1 和 thread2，同时访问对象的方法，由于该方法是 synchronized 关键字修饰的，那么这两个线程都需要获得该对象锁，一个获得后另一个线程必须等待。所以我们可以猜测运行结果应该是，一个线程执行完毕后，另一个线程才开始执行，运行例子，输出打印结果如下：

Thread-0 - 4
Thread-0 - 3
Thread-0 - 2
Thread-0 - 1
Thread-0 - 0
Thread-1 - 4
Thread-1 - 3
Thread-1 - 2
Thread-1 - 1
Thread-1 - 0

（另：thread1 和 thread2 谁先执行并不一定）
本例对于对象锁进行了基础的解释。但是对象锁的范围是怎样的，对象的某个同步方法被一个线程访问后，其他线程能不能访问该对象的其他同步方法，以及是否可以访问对象的其他非同步方法呢，下面对两种进行验证：

对两个同步方法两个线程的验证：
修改类如下，加入 minus2() 方法，和 minus() 方法一样：

package com.test.run;

public class TestSynchronized {

    public synchronized void minus() {
        int count = 5;
        for (int i = 0; i < 5; i++) {
            count--;
            System.out.println(Thread.currentThread().getName() + " - " + count);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
            }
        }
    }

    public synchronized void minus2() {
        int count = 5;
        for (int i = 0; i < 5; i++) {
            count--;
            System.out.println(Thread.currentThread().getName() + " - " + count);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
            }
        }
    }

}

测试调用如下，两个线程访问不同的方法：

public class Run {

    public static void main(String[] args) {

        final TestSynchronized test = new TestSynchronized();

        Thread thread1 = new Thread(new Runnable() {

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

        Thread thread2 = new Thread(new Runnable() {

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

        thread1.start();
        thread2.start();
    }

}

输出结果如下：

Thread-0 - 4
Thread-0 - 3
Thread-0 - 2
Thread-0 - 1
Thread-0 - 0
Thread-1 - 4
Thread-1 - 3
Thread-1 - 2
Thread-1 - 1
Thread-1 - 0

可以看到，某个线程得到了对象锁之后，该对象的其他同步方法是锁定的，其他线程是无法访问的。
下面看是否能访问非同步方法：
修改类代码如下，将 minus2() 的 synchronized 修饰去掉，代码如下：

public class TestSynchronized {

    public synchronized void minus() {
        int count = 5;
        for (int i = 0; i < 5; i++) {
            count--;
            System.out.println(Thread.currentThread().getName() + " - " + count);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
            }
        }
    }

    public void minus2() {
        int count = 5;
        for (int i = 0; i < 5; i++) {
            count--;
            System.out.println(Thread.currentThread().getName() + " - " + count);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
            }
        }
    }

}

测试调用的类不变，如下：

public class Run2 {

    public static void main(String[] args) {

        final TestSynchronized test = new TestSynchronized();

        Thread thread1 = new Thread(new Runnable() {

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

        Thread thread2 = new Thread(new Runnable() {

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

        thread1.start();
        thread2.start();

    }

}

执行结果如下：

Thread-1 - 4
Thread-0 - 4
Thread-1 - 3
Thread-0 - 3
Thread-1 - 2
Thread-0 - 2
Thread-1 - 1
Thread-0 - 1
Thread-1 - 0
Thread-0 - 0

可以看到，结果是交替的，说明线程是交替执行的，说明如果某个线程得到了对象锁，但是另一个线程还是可以访问没有进行同步的方法或者代码。进行了同步的方法（加锁方法）和没有进行同步的方法（普通方法）是互不影响的，一个线程进入了同步方法，得到了对象锁，其他线程还是可以访问那些没有同步的方法（普通方法）。当获取到与对象关联的内置锁时，并不能阻止其他线程访问该对象，当某个线程获得对象的锁之后，只能阻止其他线程获得同一个锁。

类锁

类锁需要 synchronized 来修饰静态 static 方法，写法如下：

    public static synchronized void test(){
        // TODO
    }

或者使用代码块，需引用当前的类：

    public static void test(){
        synchronized (TestSynchronized.class) {
            // TODO
        }
    }

举例说明类锁的作用：

public class TestSynchronized {

    public static synchronized void minus() {
        int count = 5;
        for (int i = 0; i < 5; i++) {
            count--;
            System.out.println(Thread.currentThread().getName() + " - " + count);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
            }
        }
    }

}

测试调用类如下：

public class Run {

    public static void main(String[] args) {

        Thread thread1 = new Thread(new Runnable() {

            @Override
            public void run() {
                TestSynchronized.minus();
            }
        });

        Thread thread2 = new Thread(new Runnable() {

            @Override
            public void run() {
                TestSynchronized.minus();
            }
        });

        thread1.start();
        thread2.start();

    }

}

输出结果如下：

Thread-0 - 4
Thread-0 - 3
Thread-0 - 2
Thread-0 - 1
Thread-0 - 0
Thread-1 - 4
Thread-1 - 3
Thread-1 - 2
Thread-1 - 1
Thread-1 - 0

可以看到，类锁和对象锁其实是一样的，由于静态方法是类所有对象共用的，所以进行同步后，该静态方法的锁也是所有对象唯一的。每次只能有一个线程来访问对象的该非静态同步方法。
类锁的作用和对象锁类似，但是作用范围是否和对象锁一致呢，下面看对象锁和类锁是否等同：
修改类，两个同步方法，其中一个是静态的：

public class TestSynchronized {

    public static synchronized void minus() {
        int count = 5;
        for (int i = 0; i < 5; i++) {
            count--;
            System.out.println(Thread.currentThread().getName() + " - " + count);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
            }
        }
    }

    public synchronized void minus2() {
        int count = 5;
        for (int i = 0; i < 5; i++) {
            count--;
            System.out.println(Thread.currentThread().getName() + " - " + count);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
            }
        }
    }

}

测试调用类如下，静态方法直接用类调用，实例方法由对象来调用：

public class Run {

    public static void main(String[] args) {

        final TestSynchronized test = new TestSynchronized();

        Thread thread1 = new Thread(new Runnable() {

            @Override
            public void run() {
                TestSynchronized.minus();
            }
        });

        Thread thread2 = new Thread(new Runnable() {

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

        thread1.start();
        thread2.start();

    }

}

运行结果：

Thread-1 - 4
Thread-0 - 4
Thread-0 - 3
Thread-1 - 3
Thread-0 - 2
Thread-1 - 2
Thread-0 - 1
Thread-1 - 1
Thread-1 - 0
Thread-0 - 0

可以看到两个线程是交替进行的，也就是说类锁和对象锁是不一样的锁，是互相独立的。

yx0628
关注
  • 86
    点赞
  • 踩
  • 244
    收藏
    觉得还不错? 一键收藏
  • 13
    评论
专栏目录
多线程（二） 同步 锁对象和条件对象
ying847782627的博客
05-29 2854
什么是线程同步？ 当使用多个线程来访问同一个数据时，非常容易出现线程安全问题(比如多个线程都在操作同一数据导致数据不一致),所以我们用同步机制来解决这些问题。 锁对象  在Java SE5.0引入ReentrantLock类。Lock是Java.util.concurrent.locks包下的接口，Lock 实现提供了比使用synchronized 方法和语句可获得的更广泛的锁定
Java之同步锁synchronized实例讲解
玻璃汽水的博客
04-28 1101
线程安全概念：当多个线程访问一个类（对象或方法）时，这个类始终都能表现出正确的行为，那么这个类（对象或方法）就是线程安全的。 1.可以在任意对象及方法上加锁，而加锁的这段代码称为"互斥区"或"临界区" 2.一般状况下，关键字synchronized取得的锁都是对象锁，而不是把一段代码（方法）当作锁。 3.在静态方法上加上synchronized关键字，表示锁定.class类（或者 synchro...
Synchronized锁详解(全网最细)
Anakki的博客
04-17 2288
正常来说a获取到锁后b不能获取锁，但是当一个实例内的a方法和b方法都是用一把锁上锁时，同一个线程访问a和b就需要重入的能力，比如在a方法中访问b方法，那么a的锁x已经被抢占了，如果不支持重入，那么访问b的时候会发现x锁已经被自己抢占而无法访问，支持重入的原理也就是在这里判断一下当前方法的锁是否是本线程拥有的锁。所以锁消除可以节省毫无意义的请求锁的时间。JVM在JDK1.6后会有几种状态，线程获取对象时，分别会判断对象锁的状态，以此来决定线程是否进入阻塞，或者获取到锁对象执行代码块，或者自旋等接下来的动作。
Java最新面试题（全网最全、最细、附答案）
最新发布
javaeEEse的博客
06-13 3029
在 Java 中，JVM 可以理解的代码就叫做字节码（即扩展名为 .class 的文件），它不面向任何特定的处理器，只面向虚拟机。Java 语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特点。所以， Java 程序运行时相对来说还是高效的（不过，和 C、 C++，Rust，Go 等语言还是有一定差距的），而且，由于字节码并不针对一种特定的机器，因此，Java 程序无须重新编译便可在多种不同操作系统的计算机上运行。
一文理清synchronized 作用范围：验证+总结
m0_71777195的博客
09-04 109
看代码过程中带着这个概念来看，万变不离其宗。把握要点，会清晰很多。不多废话，直接上代码synchronized可以修饰静态方法、普通方法、代码块；锁的类型有两种：对象锁、类锁。
使用synchronized的方法和作用
Sourcs的博客
08-09 2615
转自http://blog.csdn.net/soartju/article/details/2840491 在java编程思想中对synchronized的一点解释: 1、synchronized关键字的作用域有二种： 1）是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchr
Java中Synchronized关键字详解及使用
Cavewang的博客
10-07 1588
Java中Synchronized关键字详解及使用
9.同步代码块synchronized（对象)
khmff的博客
04-04 3030
1.synchronized(this)中的this锁住的对象是传入new Thread(st)的st对象。this锁住当前对象。 解析：若同步代码块中进入一个new Thread(st)对象，则另一个new Thread(st)线程则进不去同步代码块，除非是传入的是new Thread(st1或其他对象)就不会受影响。 2.synchronized(object obj) 3.synchronized(类.class) public class sellticket implement...
同步——锁对象和条件对象
十一的博客
12-23 330
同步 在大多数实际的多线程应用中，两个或两个以上的线程需要共享对同一数据的存取。如果每一个线程都调用修改了该数据，可能会产生错误，这种情况叫做竞争条件。为了避免多线程对共享数据的讹误，就需要学习如何同步存取。 锁对象 有两种机制防止代码块受并发访问的干扰： 1）synchronized关键字 2）ReentrantLock类 用ReentrantLock保护代码块的基本机构如下： ...
Java并发之ReentrantLock 与 synchronized
m0_69305074的博客
05-13 469
ReentrantLock ReentrantLock直译为重入锁，又称为递归锁。 是指在同一个线程中，外部方法获得锁之后，内层的递归方法依然可以获取该锁 倘若锁不具备可重入性，那么我们在第二次获取锁的时候就会造成死锁 复制代码 ReentrantLock的实现是基于AQS的，实现了锁机制和重入机制 ReentrantLock在底层有两种实现方式，分别是公平锁(FairSync)和非公平锁(NonfairSync) public ReentrantLock() { sy
java中synchronized（同步代码块和同步方法）详解及区别
08-31
在Java编程语言中，`synchronized`关键字是用于实现多线程环境下的线程安全，确保共享资源在同一时刻只能被一个线程访问。本篇文章将详细介绍`synchronized`的两种形式：同步代码块和同步方法，并分析它们的区别。 ...
Java 同步锁(synchronized)详解及实例
08-30
Java中的同步锁，即`synchronized`关键字，是Java多线程编程中用于解决并发问题的重要机制。它确保了对共享资源的互斥访问，防止数据的不一致性。当我们有多线程环境并涉及到共享数据时，可能会出现竞态条件，就像...
【Java】synchronized同步锁详解
12-22
【Java】synchronized同步锁详解 Java 中的同步机制主要用于解决多线程环境下的数据安全问题，其中synchronized关键字是Java提供的一种内置锁，也称为监视器锁或悲观锁。synchronized可以确保在同一时刻，只有一个...
Java 中 synchronized的用法详解(四种用法)
09-03
Java 中的 `synchronized` 关键字是多线程编程中的重要概念，用于实现线程同步，确保在并发环境下数据的一致性和完整性。下面将详细介绍 `synchronized` 的四种主要用法。 1. **修饰实例方法**： 当 `synchronized...
Java中synchronized关键字修饰方法同步的用法详解
09-02
【Java中synchronized关键字修饰方法同步的用法详解】 在Java多线程编程中，synchronized关键字是一个重要的同步工具，它能确保共享资源在多线程环境下的安全访问。synchronized可以用来同步静态和非静态方法，从而...
Java中Synchronized的四种用法
Isonion的博客
08-24 4390
java中Synchronized的四种用法，修饰代码块、修饰方法、修饰静态方法、修饰类
Java线程基础之Synchronized
weixin_43326254的博客
08-08 334
什么是Synchronized，Synchronized的作用
synchronized锁住的范围
爪哇岛咖啡种植农场
03-05 688
synchronized
同步锁-线程安全问题解决方案
热门推荐
程序媛泡泡的博客
03-21 5万+
1 同步锁 1.1 前言 经过前面多线程编程的学习,我们遇到了线程安全的相关问题,比如多线程售票情景下的超卖/重卖现象. 上节笔记点这里-进程与线程笔记 我们如何判断程序有没有可能出现线程安全问题,主要有以下三个条件: 在多线程程序中 + 有共享数据 + 多条语句操作共享数据 多线程的场景和共享数据的条件是改变不了的(就像4个窗口一起卖100张票,这个是业务) 所以思路可以从第3点"多条语句操作共享数据"入手,既然是在这多条语句操作数据过程中出现了问题 那我们可以把有可能出现问题的代码都包裹起来，一次只让一
java同步锁synchronized使用案例
08-30
Java中的synchronized关键字是一种用于实现同步的机制。它可以应用于方法和代码块，以确保在同一时刻只有一个线程可以访问共享资源。 以下是一些使用synchronized关键字的案例： 1. 多线程访问共享资源：考虑一个银行账户的例子，多个线程同时尝试改变账户余额。为了避免竞态条件和数据不一致的问题，可以使用synchronized关键字来同步访问共享资源，例如在deposit()和withdraw()方法上使用synchronized。 2. 线程安全的容器：在多线程环境下，使用synchronized可以确保线程安全的访问容器。例如，可以在对ArrayList的增删操作上使用synchronized，以避免多个线程同时修改容器而导致的错误。 3. 生产者-消费者模型：生产者线程负责生成数据，消费者线程负责消费数据。为了保证顺序，可以使用synchronized来同步这两个线程。例如，在生产者方法的代码块和消费者方法的代码块上使用synchronized。 4. 对象锁和类锁：synchronized可以用来实现对象级别的锁和类级别的锁。对象级别的锁是在每个对象实例上加锁，而类级别的锁是在类级别上加锁。例如，在静态方法上使用synchronized即可获得类级别的锁。 总结来说，synchronized关键字在Java中的使用案例非常广泛，可以用于多线程环境下保证共享资源的安全访问，避免并发操作导致的数据不一致问题。通过使用synchronized，可以有效地控制多个线程对共享资源的访问，确保线程安全性。
评论 13
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值