Java中synchronized关键字作用及用法

最新推荐文章于 2024-08-05 16:28:54 发布
最新推荐文章于 2024-08-05 16:28:54 发布
阅读量1.4w 收藏 89
点赞数 46
分类专栏： Java多线程 文章标签： Java 多线程 synchronized
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/qq_28082757/article/details/91542030
版权

文章目录

概念

在上篇文章介绍Volatile关键字的时候提到，synchronized 可以保障原子性和可见性。因为 synchronized 无论是同步的方法还是同步的代码块，都会先把主内存的数据拷贝到工作内存中，同步代码块结束，会把工作内存中的数据更新到主内存中，这样主内存中的数据一定是最新的。更重要的是禁用了乱序重组以及保证了值对存储器的写入，这样就可以保证可见性。

背景

现在可以多个线程对同一片存储空间进行访问，这时存储空间里面的数据叫做共享数据。线程并发给我们带来效率的同时，也带了一些数据安全性的问题，数据安全性是一个很严重的问题，多个线程同时访问同一片数据区，很有可能把里面的数据弄的混乱。 所以Java语言提供了专门机制以解决这种数据安全性问题，有效避免了同一个数据对象被多个线程同时访问，从而导致数据的错乱的问题。

synchronized关键字用法

  • synchronized关键字可以作为函数的修饰符（也就是常说的同步方法）
  • synchronized关键字可以作为函数内的语句（也就是常说的同步代码块）

示例
同步方法的写法

public synchronized void test(){}

同步代码块的写法

public void test(){
    synchronized(this){
        System.out.println("Test");
    }
}

代码synchronized(this)中的this的含义会在后面详解。

synchronized关键字的作用域

  • 对象实例： 可以防止多个线程同时访问这个对象的synchronized方法，如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程就不能同时访问这个对象中任何一个synchronized方法。这时，不同的对象实例的
    synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法。
  • 类： 可以防止多个线程同时访问这个类所创建的对象中的synchronized方法。它可以对这个类创建的所有对象实例起作用。

synchronized关键字用法及含义

synchronized 方法

它的作用域默认是当前对象，这时锁就是对象，谁拿到这个锁谁就可以运行它所控制的那段代码。如果这个对象有多个synchronized方法，其它线程就不能同时访问这个对象中任何一个synchronized方法。
示例

public class SynchronizedTest {

    /**
     * 同步方法1
     */
    public synchronized void printA(){
        System.out.println("AAAAAAAAAAAAAAAAA");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    /**
     * 同步方法2
     */
    public synchronized void printB(){
        System.out.println("BBBBBBBBBBBBBBBBB");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        // 创建一个对象实例
        SynchronizedTest synchronizedTest = new SynchronizedTest();

        /**
         * 线程1，执行该实例的printA方法
         */
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronizedTest.printA();
            }
        }).start();

        /**
         * 线程2，执行该实例的printB方法
         */
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronizedTest.printB();
            }
        }).start();
    }
}

这个示例代码很简单，在一个类里面有两个打印字符串的方法，然后在main函数里面启动两个线程去分别调用这个两个方法。

代码执行后会出现两种种打印情况
第一种：

AAAAAAAAAAAAAAAAA
（这里会等待三秒）
BBBBBBBBBBBBBBBBB
（这里会等待三秒，然后进程退出）

第二种：

BBBBBBBBBBBBBBBBB
（这里会等待三秒）
AAAAAAAAAAAAAAAAA
（这里会等待三秒，然后进程退出）

为什么会这样呢？
因为在main函数里面的两个线程都调用了start()方法后，并不是按照谁先调用start()方法，就先执行哪个线程，而是需要等待CPU的调度，那么CPU先调度谁呢？这我也不知道，因为CPU是随机的。

如果CPU先调用了线程1，因为printA()方法是synchronized修饰的，所以线程1在执行printA()方法前，先看看有没有谁把synchronizedTest对象锁住了。目前来看没有锁，那线程1就把该对象锁起来，并执行printA()方法，然后睡眠3秒钟，如果这时候，CPU又调度了线程2，那么线程2去执行的synchronized修改的printB()方法前，看到synchronizedTest对象已经被锁住了，拿不到锁，于是就只能等到synchronizedTest对象锁被释放后才能执行printB()方法了。

再假设，此时等待synchronizedTest对象锁的线程有很多，有线程1、2…10，这么多线程在等待，那么synchronizedTest对象锁被释放后，下一次对象锁会被谁拿到，也是要看CPU的心情了，不知道谁才是那个天选之子呢…

如果CPU先调用了线程2，后面的等待流程是一样的。

这个例子说明了synchronized关键字在对象实例的作用域，防止多个线程同时访问这个对象的synchronized方法，如果一个对象有多个synchronized方法，只要一个线程访问了其中的某一个synchronized方法，其它线程就不能同时访问这个对象中其他任何一个synchronized方法了。

那在对象实例的作用域概念后面还有一句话“这时，不同的对象实例的 synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法。”
现在来验证一下这句话，只需要修改上面代码中main函数的两句话，修改后如下：

public static void main(String[] args) {
	/**
	 * 线程1，执行该实例的printA方法
	 */
	new Thread(new Runnable() {
		@Override
		public void run() {
			// 创建一个对象实例
			SynchronizedTest synchronizedTest1 = new SynchronizedTest();
			synchronizedTest1.printA();
		}
	}).start();

	/**
	 * 线程2，执行该实例的printB方法
	 */
	new Thread(new Runnable() {
		@Override
		public void run() {
			// 创建一个对象实例
			SynchronizedTest synchronizedTest2 = new SynchronizedTest();
			synchronizedTest2.printB();
		}
	}).start();
}

修改的地方是把创建对象实例的地方，放在线程里面去了，此时就有两个不同的对象实例了，现在来看看执行结果呢。
也会有两种打印情况
第一种：

AAAAAAAAAAAAAAAAA
BBBBBBBBBBBBBBBBB
(等待睡眠时间结束，退出进程)

第二种：

BBBBBBBBBBBBBBBBB
AAAAAAAAAAAAAAAAA
(等待睡眠时间结束，退出进程)

两个线程并行发生，这就印证了上面这句话：不同的对象实例的 synchronized方法是不相干扰的，也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法。

思考时间？

如果我们在示例1的基础上，增加一个普通成员方法的打印方法：

/**
 * 普通成员方法1
 */
public  void printC(){
    System.out.println("CCCCCCCCCCCCCCCCC");
}

在main函数里面增加一个线程去执行这个方法：

/**
* 线程3，执行该实例的printC方法
*/
new Thread(new Runnable() {
	@Override
	public void run() {
   		synchronizedTest.printC();
	}
}).start();

看看现在的程序执行结果会是什么样的呢？可能会有6中不同的打印哦，自己试试吧，想想为什么。

synchronized 代码块

锁对象

synchronized关键字还可以用于方法中的某个代码块中，表示只对这个代码块里的资源实行互斥访问。
示例

public class SynchronizedObjTest {
    /**
     * 同步方法1
     */
    public  void printA(){
        synchronized (this){
            System.out.println("AAAAAAAAAAAAAAAAA");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 同步方法2
     */
    public void printB(){
        synchronized (this){
            System.out.println("BBBBBBBBBBBBBBBBB");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        SynchronizedObjTest synchronizedObjTest = new SynchronizedObjTest();
        /**
         * 线程1，执行该实例的printA方法
         */
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronizedObjTest.printA();
            }
        }).start();

        /**
         * 线程2，执行该实例的printB方法
         */
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronizedObjTest.printB();
            }
        }).start();
    }
}

这段代码和示例1极为相似，不同的地方在于锁的写法，synchronized (this)，中的this代表着当前对象，那么它的作用域就是当前对象，这时锁就是对象，谁拿到这个锁谁就可以运行它所控制的那段代码。如果这个对象有多个synchronized方法，其它线程就不能同时访问这个对象中任何一个synchronized方法。

那么synchronized 代码块这种做法对于同一个类的不同的对象实例的 synchronized 代码块会不会相互干扰呢？答案是不会的，就像synchronized方法一样。不同的对象实例是不同的锁，也就不会相互干扰。

锁class

可以防止多个线程同时访问这个类所创建的对象中的synchronized方法。它可以对这个类创建的所有对象实例起作用。
锁class只需要将上面代码中的this，换成“类名.class”就行了
示例

public class SynchronizedClassTest {
    /**
     * 同步方法1
     */
    public  void printA(){
        synchronized (SynchronizedClassTest.class){
            System.out.println("AAAAAAAAAAAAAAAAA");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 同步方法2
     */
    public void printB(){
        synchronized (SynchronizedClassTest.class){
            System.out.println("BBBBBBBBBBBBBBBBB");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        SynchronizedClassTest synchronizedClassTest = new SynchronizedClassTest();
        /**
         * 线程1，执行该实例的printA方法
         */
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronizedClassTest.printA();
            }
        }).start();

        /**
         * 线程2，执行该实例的printB方法
         */
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronizedClassTest.printB();
            }
        }).start();
    }
}

程序会出现两种种打印情况
第一种：

AAAAAAAAAAAAAAAAA
（这里会等待三秒）
BBBBBBBBBBBBBBBBB
（这里会等待三秒，然后进程退出）

第二种：

BBBBBBBBBBBBBBBBB
（这里会等待三秒）
AAAAAAAAAAAAAAAAA
（这里会等待三秒，然后进程退出）

现在将对象实例放在线程中去创建，使其生成两个不同的对象实例

public static void main(String[] args) {
    /**
     * 线程1，执行该实例的printA方法
     */
    new Thread(new Runnable() {
        @Override
        public void run() {
            SynchronizedClassTest synchronizedClassTest1 = new SynchronizedClassTest();
            synchronizedClassTest1.printA();
        }
    }).start();

    /**
     * 线程2，执行该实例的printB方法
     */
    new Thread(new Runnable() {
        @Override
        public void run() {
            SynchronizedClassTest synchronizedClassTest2 = new SynchronizedClassTest();
            synchronizedClassTest2.printB();
        }
    }).start();
}

修改后程序会出现两种种打印情况
第一种：

AAAAAAAAAAAAAAAAA
（这里会等待三秒）
BBBBBBBBBBBBBBBBB
（这里会等待三秒，然后进程退出）

第二种：

BBBBBBBBBBBBBBBBB
（这里会等待三秒）
AAAAAAAAAAAAAAAAA
（这里会等待三秒，然后进程退出）

修改前和修改后的打印情况是一致的。这就印证了这句话：synchronized锁class可以防止多个线程同时访问这个类所创建的对象中的synchronized方法。它可以对这个类创建的所有对象实例起作用。

在Java中还有一条隐式规则

  • 当修饰静态方法的时候，锁定的是当前类的Class对象。
  • 当修饰非静态方法的时候，锁定的是当前实例对象this。

技 术 无 他， 唯 有 熟 尔。
知 其 然， 也 知 其 所 以 然。
踏 实 一 些， 不 要 着 急， 你 想 要 的 岁 月 都 会 给 你。

江湖人称小程
关注
专栏目录
Java中synchronized的作用
jt781861965的博客
05-13 470
synchronized既保证了原子性，又保证了可见性 synchronized(Object)时，最好将Object对象定义为final类型，不要用String,Integer,Long等基础类型（常量池） object.wait()（当前线程等待，释放锁） object.notify()（随机唤醒等待线程中一个，获得锁后才可以继续执行，当前线程不会释放锁） object.notifyAll()（唤醒所有等待线程，谁获得锁后谁可以继续执行，当前线程不会释放锁） 是可重入锁，（在一个同步方法中，调用另一个同
举例讲解Java中synchronized关键字的用法
09-02
以下是对`synchronized`关键字使用方法的详细讲解： 1. **修饰实例方法**： 当`synchronized`关键字修饰一个非静态方法时，该方法的锁作用于`this`对象，即当前实例对象。这意味着，如果两个线程分别通过不同的...
Java中Synchronized的四种用法
Isonion的博客
08-24 4969
java中Synchronized的四种用法，修饰代码块、修饰方法、修饰静态方法、修饰类
Java并发编程(四)—synchronized关键字的应用
最新发布
echola_mendes的博客
08-05 1531
synchronized 关键字是 Java 中用来确保线程安全的基本机制，特别是在需要保证多个变量之间的一致性时。通过使用 synchronized，可以锁定一个对象，从而确保同一时刻只有一个线程可以访问该对象可以将 synchronized 用于方法级别和代码块级别，要注意锁定的对象应该是一个合适的对象，不能是一个常量，使用 synchronized 可以简化并发控制逻辑，但需要注意其性能开销和潜在的死锁风险。
java中synchronized关键字作用分析
金龙的专栏
06-22 330
<br />  <br />1、synchronized关键字的作用域有二种：<br />　　1） 是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的 synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同
synchronized的作用
good_youth的专栏
08-07 575
 synchronized的作用 一、同步方法public synchronized void methodAAA(){//….}锁定的是调用这个同步方法的对象测试：a、不使用这个关键字修饰方法，两个线程调用同一个对象的这个方法。目标类：1public class TestThread {2    public  void execute(){  //synchronized,
synchronized关键字的作用是什么？
weixin_53180424的博客
01-27 826
需要注意的是，synchronized 是以对象为单位进行同步的，不同线程对同一个对象的 synchronized 代码块或方法的访问会进行互斥操作。当一个线程释放锁时，会将对共享变量的更新刷新到主内存中，而当另一个线程获取锁时，会从主内存中重新读取最新的值，保证了线程间的数据可见性。因此，在设计同步代码时，应避免出现循环依赖的锁请求关系，或使用锁的超时机制来解决潜在的死锁问题。同步粒度：应尽量缩小 synchronized 的作用范围，只对必要的代码进行同步，以减少锁竞争，提高程序的并发性能。
java中synchronized的作用
阳光心态，健康人生的博客
08-31 315
下面的这篇文章介绍的非常具体 原文：http://blog.csdn.net/luoweifu/article/details/46613015 作者:luoweifu 转载请标名出处
Java中synchronized关键字修饰方法同步的用法详解
09-02
【Java中synchronized关键字修饰方法同步的用法详解】 在Java多线程编程中，synchronized关键字是一个重要的同步工具，它能确保共享资源在多线程环境下的安全访问。synchronized可以用来同步静态和非静态方法，从而...
Java synchronized关键字使用方式及特性解析
08-25
在Java中，使用synchronized关键字可以作用在方法上，从而保证了访问同一个对象的同一个方法的线程同步。例如： public synchronized void testFun(String str){ for(int i=0;i;i++){ System.out.println(str+",...
Java中synchronized关键字引出的多种锁 问题
08-25
Java中synchronized关键字引出的多种锁问题 Java 中的 synchronized 关键字可以在多线程环境下用来作为线程安全的同步锁。synchronized 关键字有三种用法，分别为：用在普通方法上，能够锁住当前对象；用在静态方法...
详解Java中synchronized关键字的死锁和内存占用问题
09-02
总之，理解和合理使用`synchronized`关键字是Java多线程编程中的基础，但同时也要注意避免潜在的死锁问题和过度使用导致的内存占用问题。正确选择同步机制，结合适当的并发工具，能够有效地提高多线程程序的效率和...
java synchronized的作用_Java中synchronized详解
weixin_30819757的博客
03-06 1211
synchronized官方解释翻译成中文：Synchronized同步方法可以支持使用一种简单的策略来防止线程干扰和内存一致性错误：如果一个对象对多个线程可见，则对该对象变量的所有读取或写入都是通过同步方法完成的。简单就是说Synchronized的作用就是Java中解决并发问题的一种最常用最简单的方法 ，他可以确保同一个时刻最多只有一个线程执行同步代码，从而保证多线程环境下并发安全的效果。sy...
java中synchronized关键字的用法
laly123321的博客
11-10 132
Java中有哪些机制保证线程安全 初阶阶段，只学习几个基本 1.synchronized ——监视器锁 ——monitor lock 2.volatile 关键字 3.基本通信 wait/notify… synchronized 语法：1.作为方法的一个修饰符 2.作为代码块出现 演示代码： public class SynchronizedDemo { public void met...
synchronized关键字的作用(zz)
创业、新知、分享
12-20 1536
   Java对多线程的支持与同步机制深受大家的喜爱，似乎看起来使用了synchronized关键字就可以轻松地解决多线程共享数据同步问题。到底如何？――还得对synchronized关键字的作用进行深入了解才可定论。   总的说来，synchronized关键字可以作为函数的修饰符，也可作为函数内的语句，也就是平时说的同步方法和同步语句块。如果再细的分类，synchronized可作用于in
synchronized
开发笔记
08-27 67
在多线程的情况下，由于同一进程的多个线程共享同一片存储空间，在带来方便的同时，也带来了访问冲突这个严重的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问。由于我们可以通过 private 关键字来保证数据对象只能被方法访问，所以我们只需针对方法提出一套机制，这套机制就是 synchronized 关键字，它包括两种用法：synchronized 方法和 s...
synchronized关键字作用和原理
Imzhipo的博客
04-25 1319
结果：从结果看出虽然方法用的synchronized修饰 线程1和2是并发并发执行的，因为线程1使用的对象SynchronizedClass1而线程2使用的是对象SynchronizedClass2，两个线程使用的不同的对象，而synchronized修饰普通方法是以this当前对象为锁，线程1this对象是SynchronizedClass1，线程2this对象是SynchronizedClass2，所以两线程运行没有影响。非同步方法2 非静态方法 线程 Thread2 运行结束。
Java 中 Synchronized 关键字的作用
IT徐师兄
04-27 382
Java 中 Synchronized 关键字的作用
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值