java关键字【synchronized】

最新推荐文章于 2024-03-06 17:33:13 发布
最新推荐文章于 2024-03-06 17:33:13 发布
阅读量1.2k 收藏 35
点赞数 39
分类专栏： java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42049505/article/details/135263147
版权

一、是什么

synchronized关键字是java中用于解决多线程并发问题的一种机制，它可以确保同一时刻只有一个线程能够访问共享资源，从而避免了数据竞争和其它并发问题。

1.1. 作用

  • 防止线程干扰和内存一致性错误：通过确保同一时刻只有一个线程能够访问共享资源，可以避免多个线程同时修改共享资源的情况，从而防止线程干扰和内存一致性错误。
  • 确保监视资源的可见性：在多线程环境中，使用synchronized关键字可以确保监视资源的可见性，即当一个线程获得Monitor后，将共享内存中的数据复制到该线程的site的缓存中，其它线程也可以看到该数据。
  • 确保线程间的有序运行：通过synchronized关键字可以确保方法或代码块在操作中的原子性，即同一时间最多只有一个线程访问该方法或代码块，并且不会触发JMM指令重排机制。

1.2. 修饰情况

  • 方法：可以修饰实例方法可静态方法。当一个方法被syncronized修饰时，该方法一次只能被一个线程访问。
  • 代码块：可以修饰实例方法和静态方法中的代码块，叫同步代码块。通常需要在synchronized()中指明进入同步代码块的key，这里的key可以是Object、this或者class。

二、修饰方法

注意：为了保证逻辑中变量count�的原子性，其类型使用AtomicInteger�。

2.1. 代码示例（修饰普通方法）

public class test {
    private static AtomicInteger count = new AtomicInteger();
    public static void main(String[] args) {
        Counter counter = new Counter();
        Thread thread1 = new Thread(() -> { //线程1
            counter.increase(count);
        });
        Thread thread2 = new Thread(() -> { //线程2
            counter.increase(count);
        });
        thread1.start();
        thread2.start();
    }
}
class Counter {
    public synchronized void increase(AtomicInteger count) {
        count.incrementAndGet();
        System.out.println(Thread.currentThread().getName() + ":" + count);
    }
}

输出结果为：
图片.png
说明：因为thread0中的increase()方法和thread1中的increase()方法都是通过counter对象调用，它们用的是同一个对象锁，互斥。所以，thread1一直等到thread0中的increase()方法执行完释放后才开始执行thread1的increase()方法。
修改代码，每个线程分别创建一个Counter对象：

public class test {
    private static AtomicInteger count = new AtomicInteger();
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> { //线程1
            Counter counter1 = new Counter();
            counter1.increase(count);
        });
        Thread thread2 = new Thread(() -> { //线程2
            Counter counter2 = new Counter();
            counter2.increase(count);
        });
        thread1.start();
        thread2.start();
    }
}
class Counter {
    public synchronized void increase(AtomicInteger count) {
        count.incrementAndGet();
        System.out.println(Thread.currentThread().getName() + ":" + count);
    }
}

输出结果为：
图片.png
说明：因为thread0中的increase()方法是通过counter1对象调用的，thread1中的increase()方法是通过counter2对象调用，它们用的是两个不同的对象锁，并不互斥。所以，thread1中的increase()方法和thread0中的increase()方法是同时进行的。
结论：使用"同一对象"去调用其被synchronized修饰的普通方法才互斥。

2.2. 代码示例（修饰静态方法）

public class test {
    private static AtomicInteger count = new AtomicInteger();
    public static void main(String[] args) {
        Counter counter = new Counter();
        Thread thread1 = new Thread(() -> { //线程1
            counter.increase(count);
        });
        Thread thread2 = new Thread(() -> { //线程2
            counter.increase(count);
        });
        thread1.start();
        thread2.start();
    }
}
class Counter {
    public synchronized static void increase(AtomicInteger count) {
        count.incrementAndGet();
        System.out.println(Thread.currentThread().getName() + ":" + count);
    }
}

输出结果为：
图片.png
修改代码，每个线程分别创建一个Counter对象：

public class test {
    private static AtomicInteger count = new AtomicInteger();
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> { //线程1
            Counter counter1 = new Counter();
            counter1.increase(count);
        });
        Thread thread2 = new Thread(() -> { //线程2
            Counter counter2 = new Counter();
            counter2.increase(count);
        });
        thread1.start();
        thread2.start();
    }
}
class Counter {
    public synchronized static void increase(AtomicInteger count) {
        count.incrementAndGet();
        System.out.println(Thread.currentThread().getName() + ":" + count);
    }
}

输出结果为：
图片.png
说明：因为increase()方法是Counter类里的静态方法，并且被synchronized修饰，所以这个方法是靠唯一的Counter类锁工作，所以无论是通过Counter类调用还是new不同的counter对象，都是互斥的。
结论： 被synchronized修饰的静态方法靠类锁工作。当多个线程同时访问某个被synchronized修饰的静态方法时，一旦某个进程抢得该类的类锁后，其它进程只能排队。如果该类包含多个被synchronized修饰的静态方法，只要有一个静态方法被某一线程获得类锁，即使其它线程调用其它被synchronized修饰的静态方法也需要排队。

2.3. 原理

它的原理是在方法的flags中增加ACC_SYNCHRONIZED标记，有ACC_SYNCHRONIZED标记的方法在被调用时，调用指令会先去检查方法的ACC_SYNCHRONIZED访问标志是否设置，如果设置了执行线程先要持有同步锁，然后才去执行方法，否则相关线程会被阻塞。
通过以上第一个修饰普通方法代码，反编译increase()结果如下(javap -c -v Counter.class)：
图片.png注意：方法要public修饰，否则在反编译代码中看不到。
从反编译结果可以看出ACC_SYNCHRONIZED标记，表明该方法是synchronized的，同时还可能会有ACC_PUBLIC和ACC_STATIC，这两个标记分别表示访问权限和是否是静态方法。

三、修饰代码块

3.1. 代码示例（修饰class）

public class test {
    private static AtomicInteger count = new AtomicInteger();
    public static void main(String[] args) {
        Counter counter = new Counter();
        Thread thread1 = new Thread(() -> { //线程1
            counter.increase(count);
        });
        Thread thread2 = new Thread(() -> { //线程2
            counter.increase(count);
        });
        thread1.start();
        thread2.start();
    }
}
class Counter {
    public void increase(AtomicInteger count) {
        synchronized (Counter.class) {
            count.incrementAndGet();
            System.out.println(Thread.currentThread().getName() + ":" + count);
        }
    }
}

输出结果为：
图片.png
修改代码，每个线程分别创建一个Counter对象：

public class test {
    private static AtomicInteger count = new AtomicInteger();
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> { //线程1
            Counter counter1 = new Counter();
            counter1.increase(count);
        });
        Thread thread2 = new Thread(() -> { //线程2
            Counter counter2 = new Counter();
            counter2.increase(count);
        });
        thread1.start();
        thread2.start();
    }
}
class Counter {
    public void increase(AtomicInteger count) {
        synchronized (Counter.class) {
            count.incrementAndGet();
            System.out.println(Thread.currentThread().getName() + ":" + count);
        }
    }
}

输出结果：
图片.png
结论：synchronized在修饰class时，同步代码块只有同一个类的实例访问。因此，如果有多个实例属于同一个类，它们将共享同一个锁，并且只能有一个线程同时执行该类的同步代码块。所以，即使创建多个对象也会排序执行被锁的代码块。

3.2. 示例代码（修饰this）

public class test {
    private static AtomicInteger count = new AtomicInteger();
    public static void main(String[] args) {
        Counter counter = new Counter();
        Thread thread1 = new Thread(() -> { //线程1
            counter.increase(count);
        });
        Thread thread2 = new Thread(() -> { //线程2
            counter.increase(count);
        });
        thread1.start();
        thread2.start();
    }
}
class Counter {
    public void increase(AtomicInteger count) {
        synchronized (this) {
            count.incrementAndGet();
            System.out.println(Thread.currentThread().getName() + ":" + count);
        }
    }
}

输出结果：
图片.png
修改代码，每个线程分别创建一个Counter对象：

public class test {
    private static AtomicInteger count = new AtomicInteger();
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> { //线程1
            Counter counter1 = new Counter();
            counter1.increase(count);
        });
        Thread thread2 = new Thread(() -> { //线程2
            Counter counter2 = new Counter();
            counter2.increase(count);
        });
        thread1.start();
        thread2.start();
    }
}
class Counter {
    public void increase(AtomicInteger count) {
        synchronized (this) {
            count.incrementAndGet();
            System.out.println(Thread.currentThread().getName() + ":" + count);
        }
    }
}

输出结果：
图片.png
结论：synchronized在修饰this时，只能确保同一对象下所有线程代码之间的同步代码块互斥（线程安全），而不同对象的的线程是不受影响的（线程不安全）。

3.3. 示例代码（修饰非静态Object）

public class test {
    private static AtomicInteger count = new AtomicInteger();
    public static void main(String[] args) {
        Counter counter = new Counter();
        Thread thread1 = new Thread(() -> { //线程1
            counter.increase(count);
        });
        Thread thread2 = new Thread(() -> { //线程2
            counter.increase(count);
        });
        thread1.start();
        thread2.start();
    }
}
class Counter {
    private Object lockObj = new Object();
    public void increase(AtomicInteger count) {
        synchronized (lockObj) {
            count.incrementAndGet();
            System.out.println(Thread.currentThread().getName() + ":" + count);
        }
    }
}

输出结果：
图片.png
修改代码，每个线程分别创建一个Counter对象：

public class test {
    private static AtomicInteger count = new AtomicInteger();
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> { //线程1
            Counter counter1 = new Counter();
            counter1.increase(count);
        });
        Thread thread2 = new Thread(() -> { //线程2
            Counter counter2 = new Counter();
            counter2.increase(count);
        });
        thread1.start();
        thread2.start();
    }
}
class Counter {
    private Object lockObj = new Object();
    public void increase(AtomicInteger count) {
        synchronized (lockObj) {
            count.incrementAndGet();
            System.out.println(Thread.currentThread().getName() + ":" + count);
        }
    }
}

输出结果：
图片.png
结论：synchronized在修饰非静态object时，只能确保同一对象下所有线程代码之间的同步代码块互斥（线程安全），而不同对象的的线程是不受影响的（线程不安全），类似于this。

3.4. 示例代码（修饰静态Object）

public class test {
    private static AtomicInteger count = new AtomicInteger();
    public static void main(String[] args) {
        Counter counter = new Counter();
        Thread thread1 = new Thread(() -> { //线程1
            counter.increase(count);
        });
        Thread thread2 = new Thread(() -> { //线程2
            counter.increase(count);
        });
        thread1.start();
        thread2.start();
    }
}
class Counter {
    private static Object lockObj = new Object();
    public void increase(AtomicInteger count) {
        synchronized (lockObj) {
            count.incrementAndGet();
            System.out.println(Thread.currentThread().getName() + ":" + count);
        }
    }
}

输出结果：
图片.png
修改代码，每个线程分别创建一个Counter对象：

public class test {
    private static AtomicInteger count = new AtomicInteger();
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> { //线程1
            Counter counter1 = new Counter();
            counter1.increase(count);
        });
        Thread thread2 = new Thread(() -> { //线程2
            Counter counter2 = new Counter();
            counter2.increase(count);
        });
        thread1.start();
        thread2.start();
    }
}
class Counter {
    private static Object lockObj = new Object();
    public void increase(AtomicInteger count) {
        synchronized (lockObj) {
            count.incrementAndGet();
            System.out.println(Thread.currentThread().getName() + ":" + count);
        }
    }
}

输出结果：
图片.png
结论：synchronized在修饰静态object时，同步代码块只有同一个类的实例访问。因此，如果有多个实例属于同一个类，它们将共享同一个锁，并且只能有一个线程同时执行该类的同步代码块。所以，即使创建多个对象也会排序执行被锁的代码块，类似于class。

3.5. 原理

synchronized修饰代码块是通过monitorenter和monitorexit指令进行同步处理的。monitorenter指令用于进入synchronized代码块或方法，它会尝试获取一个锁，如果锁已经被其它线程持有，则该线程将被阻塞；monitorexit指令用于退出synchronized代码块或方法，它会释放锁，这样其它等待的线程就可以获取到锁并执行。
通过以上第一个修饰class代码，反编译increase()结果如下(javap -c -v Counter.class)：
图片.png

搬救兵
关注
专栏目录
【java】java 关键字: synchronized详解
九师兄
12-21 7101
关键字: synchronized详解【Java】Synchronized 有几种用法【java】 从hotspot底层对象结构理解锁膨胀升级过程【java】动态高并发时为什么推荐重入锁而不是Synchronized？请带着这些问题继续后文，会很大程度上帮助你更好的理解synchronized。Synchronized可以作用在哪里?分别通过对象锁和类锁进行举例。Synchronized本质上是通过什么保证线程安全的?分三个方面回答：加锁和释放锁的原理，可重入原理，保证可见性原理。
java关键字Synchronized详解
07-04
Java中的`synchronized`关键字是实现线程同步的关键机制，它保证了在多线程环境下，对共享资源的访问是互斥的，防止了数据竞争和不一致的问题。synchronized通过锁的概念来控制对代码块或方法的访问，分为两种形式：...
Java中的synchronized关键字
林隐的博客
11-30 1193
Java中的synchronized关键字
Java中的synchronized 关键字
gehulushang的博客
05-19 291
synchronized关键字相关的一些知识点 简单描述： 关键字synchronized具有使每个线程依次排队操作共享变量的功能。 并发编程中，经常遇到多个线程访问同一个 共享资源 ，这时候作为开发者必须考虑如何维护数据一致性。 synchronized关键字常被用于维护数据一致性，利用synchronized机制是给共享资源上锁，只有拿到锁的线程才可以访问共享资源，这样就可以强制使得对...
java sychronized关键字
xichengxml的博客
10-09 140
/** * synchronized关键字 * 对某个对象加锁 * @author liubin */ package yxxy.c_001; public class T { private int count = 10; private Object o = new Object(); public void m() ...
java中synchronized关键字
龙空白白的博客
06-10 4047
synchronized是java中的一个关键字，在中文中为同步，也被称之为’同步锁’,以此来达到多线程并发访问时候的并发安全问题，可以用来修饰代码块、非静态方法。静态方法等； 修饰代码块时:给当前指定的对象加锁 修饰非静态方法时:作用于当前实例加锁 修饰静态方法时:作用于当前类对象加锁 synchronized在java内存模型中的主要作用 原子性:通过monitorenter和monitorexit指令,保证被synchronized修饰的代码在同一时间只能被一个线程访问，在锁未释放之前，无法被其他线程
 java关键字synchronized有什么用
06-07
Java关键字synchronized主要用于实现线程同步，可以用来保证在同一时刻只有一个线程可以执行某个方法或某个代码块。具体来说，当一个线程获取了某个对象的synchronized锁时，其他线程就不能在该对象的同步代码块或...
 java关键字synchronized
04-10
synchronized关键字用于Java中实现线程同步，以确保多个线程不会同时访问共享资源。在synchronized块中，只能有一个线程访问共享资源，其他线程必须等待该线程释放锁，才能进入synchronized块。这可以防止并发访问...
Java关键字volatile和synchronized作用和区别
08-30
Java关键字volatile和synchronized作用和区别 Java关键字volatile和synchronized是Java语言中两个常用的关键字，它们都是用来解决多线程编程中的同步问题的，但它们的作用和用法却有所不同。 volatile关键字是变量...
Java中的Synchronized关键字
老徐的博客只有干货
06-06 349
1.介绍 简单的讲，在多线程环境中，当一个或多个线程试图更新一个可变共享数据时会出现竞争情况，你无法确定共享数据将如何变化。Java通过同步线程获取共享资源方式可以做到避免此竞争。 使用 synchronized 关键字的代码变成一个 synchronized 块，同一时间只允许一个线程执行。 2.为什么要同步机制？ 让我们考虑以下代码在多线程情况下的执行结果： public class SynchronizedMethods { private int sum = 0; public
Java关键字——synchronized
qq_35854212的博客
02-16 730
synchronized使用和原理全解
java基础 - synchronized关键字
软件测试入门笔记
04-29 372
java基础
详解synchronized关键字（Java）
最新发布
weixin_66046886的博客
03-06 1685
这篇博客博主将详细地介绍地介绍Java中的synchronized关键字，坐好板凳发车啦~
java synchronized关键字的用法
chenchao2017的博客
11-03 2818
背景 最近在工作遇到一种用来校验的资源要定时更新的情况，为了保证在资源更新的时候不被其他的线程所访问， 就学习了synchronized 的同步块来解决这个功能。 原理 在java中，每一个对象都有一把内置锁，当程序中的某一块代码被同步块包起来的时候（synchronized(this){...}），相当于电脑用this指向的对象的内置锁把这块代码锁起来了，只有拥有能解开着这把锁钥
java+synchorized例子_java笔记三——synchronized几个实例
weixin_36307713的博客
02-23 182
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/alex197963/archive/2009/08/06/4417414.aspx一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。二、然而，当一个线程访问object...
java synchronized 实现_java中synchronized关键字的实现
weixin_35133182的博客
02-16 76
说明：java中的同步(synchronized)是基于进入monitor对象和退出monitor对象来实现的，无论是显式同步还是隐式同步。synchronized语句块：1)(使用javap -c 类名)将class文件反编译后可以看到：同步块的入口位置和出口位置(方法结束处和异常处)分别插入了monitorenter字节码指令和monitorexit字节码指令，故同步代码块属于显示同步。2)线...
Java线程基础之Synchronized
weixin_43326254的博客
08-08 393
什么是Synchronized，Synchronized的作用
使用synchronized需要注意的一个问题
JimmyLincole的专栏
12-07 3676
说到synchronized这个关键字，大伙第一时间想到的，可能就是：当资源共享时,访问(修改)该资源的所有方法都要加上锁(synchronized),才能保证数据不会出错(数据不一致)； Java提供了专门的机制去避免了同一个数据对象被多个线程同时访问，这套机制就是 synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。 1.
聊聊Java关键字synchronized
Hi，我是sharkchili，CSDN Java领域博客专家，开源项目JavaGuide维护人员，我想写一些有意思的东西，希望对你有帮助。
02-13 4254
具体例子，某段线程得到锁Test.class之后，执行临界代码逻辑，可能会先执行变量b初始化的逻辑，在执行a变量初始化的逻辑，但是最终结果都会执行a+b的逻辑。每个线程使用synchronized获得锁操作临界资源时，首先需要获取临界资源的值，为了保证临界资源的值是最新的，JMM模型规定线程必须将本地工作内存清空，到共享内存中加载最新的进行操作。正是由于锁互斥的失败，导致两个线程同时到临界区域加载资源，获得的count都是0，经过自增后都是1，导致数据少了1。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值