线程安全性（一） 原子性 基于锁的实现 - synchronized修饰方法

最新推荐文章于 2024-01-29 09:59:01 发布
最新推荐文章于 2024-01-29 09:59:01 发布
阅读量111 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_33669968/article/details/88889799
版权

synchronized修饰方法 - 正例

  • 同一个对象在不同线程中访问同步方法，同步方法对这些线程是能起到同步作用的；
  • 如果SynchronizedMethod是个父类，那么子类中的test2()是带不上synchronized的；
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@Slf4j
public class SynchronizedMethod {

    public synchronized void test2(int j) {
        for (int i = 0; i < 10; i++) {
            log.info("synchronized method object {} - {}", j, i);
        }
    }

    public static void main(String[] args) {
        testMethodSync();
    }

    private static void testMethodSync() {
        SynchronizedMethod example1 = new SynchronizedMethod();
        ExecutorService service = Executors.newCachedThreadPool();
        service.execute(() -> {
            example1.test2(1);
        });
        service.execute(() -> {
            example1.test2(1);
        });
    }

}

输出：

  • 同一个对象所在的2个线程按顺序先后执行；

17:14:54.487 [pool-1-thread-1] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 1 - 0
17:14:54.492 [pool-1-thread-1] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 1 - 1
17:14:54.492 [pool-1-thread-1] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 1 - 2
17:14:54.492 [pool-1-thread-1] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 1 - 3
17:14:54.492 [pool-1-thread-1] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 1 - 4
17:14:54.492 [pool-1-thread-1] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 1 - 5
17:14:54.492 [pool-1-thread-1] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 1 - 6
17:14:54.492 [pool-1-thread-1] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 1 - 7
17:14:54.492 [pool-1-thread-1] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 1 - 8
17:14:54.492 [pool-1-thread-1] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 1 - 9
17:14:54.492 [pool-1-thread-2] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 1 - 0
17:14:54.492 [pool-1-thread-2] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 1 - 1
17:14:54.492 [pool-1-thread-2] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 1 - 2
17:14:54.492 [pool-1-thread-2] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 1 - 3
17:14:54.492 [pool-1-thread-2] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 1 - 4
17:14:54.492 [pool-1-thread-2] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 1 - 5
17:14:54.493 [pool-1-thread-2] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 1 - 6
17:14:54.493 [pool-1-thread-2] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 1 - 7
17:14:54.493 [pool-1-thread-2] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 1 - 8
17:14:54.493 [pool-1-thread-2] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 1 - 9

synchronized修饰方法 - 反例

  • 不同对象在不同线程中访问同步方法，同步方法对不同调用对象是不能起到同步作用的；
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@Slf4j
public class SynchronizedMethod {

    public synchronized void test2(int j) {
        for (int i = 0; i < 10; i++) {
            log.info("synchronized method object {} - {}", j, i);
        }
    }

    public static void main(String[] args) {
        testMethodNotSync();
    }

  private static void testMethodNotSync() {
        SynchronizedMethod example1 = new SynchronizedMethod();
        SynchronizedMethod example2 = new SynchronizedMethod();
        ExecutorService service = Executors.newCachedThreadPool();
        service.execute(() -> {
            example1.test2(1);
        });
        service.execute(() -> {
            example2.test2(2);
        });
    }

}

输出：

  • 乱序的，两个对象所在的线程同时执行；

17:19:00.185 [pool-1-thread-2] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 2 - 0
17:19:00.185 [pool-1-thread-1] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 1 - 0
17:19:00.190 [pool-1-thread-1] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 1 - 1
17:19:00.190 [pool-1-thread-2] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 2 - 1
17:19:00.190 [pool-1-thread-1] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 1 - 2
17:19:00.190 [pool-1-thread-2] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 2 - 2
17:19:00.190 [pool-1-thread-1] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 1 - 3
17:19:00.190 [pool-1-thread-2] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 2 - 3
17:19:00.191 [pool-1-thread-1] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 1 - 4
17:19:00.191 [pool-1-thread-2] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 2 - 4
17:19:00.191 [pool-1-thread-1] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 1 - 5
17:19:00.191 [pool-1-thread-2] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 2 - 5
17:19:00.191 [pool-1-thread-1] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 1 - 6
17:19:00.191 [pool-1-thread-2] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 2 - 6
17:19:00.191 [pool-1-thread-1] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 1 - 7
17:19:00.191 [pool-1-thread-2] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 2 - 7
17:19:00.191 [pool-1-thread-1] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 1 - 8
17:19:00.191 [pool-1-thread-2] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 2 - 8
17:19:00.191 [pool-1-thread-1] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 1 - 9
17:19:00.191 [pool-1-thread-2] INFO com.example.concurrency.example.SynchronizedMethod - synchronized method object 2 - 9

乌鲁木齐001号程序员
关注
Java并发编程面试题——线程安全（原子性、可见性、有序性）
二蛋的博客
02-16 4623
一、原子性高频问题 1.1 Java中如何实现线程安全? 1.2 CAS底层实现 1.3 CAS的常见问题 1.4 四种引用类型 + ThreadLocal的问题？ 二、可见性高频问题 2.1 Java的内存模型 2.2 保证可见性的方式 2.3 volatile修饰引用数据类型 2.4 有了MESI协议，为啥还有volatile？ 2.5 volatile的可见性底层实现 三、有序性高频问题 3.1 什么是有序性问题 3.2 volatile的有序性底层实现 四、synchronized高频问题 4.1
Java并发编程------线程安全问题：原子性，可见性，有序性和其物理层原理
并发编程------线程状态（thread.interrupt）
03-28 533
线程安全问题有什么？ 为什么产生有线程安全问题？ 怎么解决线程安全问题？ 一般线程安全有三类——可见性问题，原子性问题，有序性问题。 可见性：当某一个线程修改了某个共享变量，应及时让其他线程知道。而不会当线程A修改了共享变量，而线程B获取到的仍然是旧的值。 原子性：首先确定的是，原子性是针对共享变量和多线程而存在的。 当某一个线程访问（读、写）某个共享变量的时候，对于其他的线程来说，这个线程只存在...
原子操作的实现原理（锁和循环CAS）
cristianoxm的博客
06-02 792
本文转自https://www.cnblogs.com/duanxz/archive/2012/08/09/2630071.html 一、引言 原子（atom）本意是“不能被进一步分割的最小粒子”，而原子操作（atomic operation）意为”不可被中断的一个或一系列操作” 。在多处理器上实现原子操作就变得有点复杂。本文让我们一起来聊一聊在Inter处理器和Java里是如何实现原子操作的。 二、术语定义 三、处理器如何实现原子操作 32位IA-32处理器使用基于对缓存加锁或总线加锁的方式来实现多处理
同步锁与原子锁
a123456horizon的博客
01-03 305
public class TestLock { public static int count = 0; public static void main(String[] args) { for( int i = 0; i < 2; i ++) { new Thread( new Runnable() { public void run() {
线程安全性（一） 原子性 基于锁的实现 - synchronized修饰静态方法
乌鲁木齐001号程序员
03-27 139
synchronized修饰静态方法示例 synchronized修饰静态方法，其作用对象是这个类的所有对象； 2个不同的对象在不同的线程中访问静态方法，按顺序一个一个线程的执行，不会多个线程同时执行； import lombok.extern.slf4j.Slf4j; import java.util.concurrent.ExecutorServ...
关于原子锁的理解
OX_CC的专栏
10-27 529
<br />这几天研究了一下原子锁函数。 <br /> <br /><br /> 以下为加一原子锁函数声明：<br />WINBASEAPI <br /> LONG <br /> WINAPI <br /> InterlockedIncrement ( <br />     __inout LONG volatile *lpAddend <br />     ); <br /><br /> 以下为函数反汇编代码： <br /> 7C809776  mov         ec
线程原子锁用法 14.4.29
luoqiang0831的专栏
04-29 452
// ThreadyzLock1.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include "windows.h" #include "conio.h" long g_Value=0; long g_Value2=0; DWORD WINAPI InterProcl(L
【学习笔记】线程原子性-锁 synchronized的用法，rabbitmq与kafka面试
澎湖Java架构师的博客
12-23 117
//两个线程调用了同一个对象 executorService.execute(() ->{ example1.test1(1); }); executorService.execute(() ->{ example2.test1(2); }); } } 返回结果： test1 j：1 — i：0 test1 j：1 — i：1 test1 j：1 — i：2 test1 j：1 — i：3 test1 j：1 — i：4 test1 j：1 — i：5 test1 j
java static方法 引用static属性 存在线程安全问题-原理分析
12-21
这样，每次只有一个线程能够执行`test()`方法，确保了对`a`的修改是原子性的，并且修改后的结果对其他线程是可见的。 总结来说，Java中的静态方法和静态属性在多线程环境下直接访问会存在线程安全问题，因为它们是...
Java并发编程系列- synchronized
06-16
在Java编程语言中，`synchronized`关键字是并发编程中的关键概念，它用于控制多线程对共享资源的访问，以避免数据不一致性和线程安全问题。本篇文章将深入探讨`synchronized`的使用及其在Java并发编程中的作用。 ...
javascript基础学习系列三百一十六：原子读和写
最新发布
wanmeijuhao的博客
01-29 964
浏览器的 JavaScript 编译器和 CPU 架构本身都有权限重排指令以提升程序执行效率。正常情况下， JavaScript 的单线程环境是可以随时进行这种优化的。但多线程下的指令重排可能导致资源争用，而且 极难排错。Atomics API 通过两种主要方式解决了这个问题。 所有原子指令相互之间的顺序永远不会重排。 使用原子读或原子写保证所有指令(包括原子和非原子指令)都不会相对原子读/写重新排序。这意味着位于原子读/写之前的所有指令会在原子读/写发生前完成。
Java中Synchronized的使用
qinming的博客
03-20 268
Synchronized是Java语言的关键字，可以使用它来修饰方法或者代码块，Synchronized能够保证被它修饰的方法或代码块在同一时刻最多只有一个线程执行该段代码，这里我将介绍由它来分别修饰静态方法，示例方法，以及代码块是如何使用的。 1、修饰静态方法 Synchronized修饰静态方法它的锁就是当前的class对象，那么如果当该类有多个Synchronized修饰的静态方法时，一次只有一个线程能执行其中的一个Synchronized修饰的静态方法，同时Synchronized还是可重入锁.
多线程的那点儿事（之原子锁）
java开发指南博客 【转载】
11-28 574
【 声明：版权所有，欢迎转载，请勿用于商业用途。 联系信箱：feixiaoxing @163.com】 原子锁是多线程编程中的一个特色。然而，在平时的软件编写中，原子锁的使用并不是很多。这其中原因很多，我想主要有两个方面。第一，关于原子锁这方面的内容介绍的比较少；第二，人们在编程上面习惯于已有的方案，如果没有特别的需求，不过贸然修改已存在的代码。毕竟对很多人来说，不求有功，但求无过。保持当前代...
js 原子级操作_原子操作类（一）原子操作类详细介绍
weixin_39528994的博客
12-20 696
引言Java从JDK1.5开始提供了java.util.concurrent.atomic包，方便程序员在多线程环境下，无锁的进行原子操作。原子变量的底层使用了处理器提供的原子指令，但是不同的CPU架构可能提供的原子指令不一样，也有可能需要某种形式的内部锁,所以该方法不能绝对保证线程不被阻塞。因为变量的类型有很多种，所以在Atomic包里一共提供了13个类，可分为4种类型的原子更新方式，分别是原子...
记一次调用service实现类Synchronized同步锁失效的坑
dzy_001的博客
05-10 5404
我的同步方法是这样写的 @Override @Transactional(rollbackFor = Exception.class) public synchronized SyTaskChildDO initTaskChild(SyTaskChildQueryParam param) { try { List<SyTaskChildDO> taskCid...
js模拟java同步锁
ma345787383的博客
03-15 7244
有这方面知识的朋友，看到题目会认为，你这样做没有意义的，因为script脚本永远不会产生并发。确实脚本执行是单线程的，即使有setTimeout、setInterval等方法，他也永远不会产生并发。所以这里只是模拟。   　　说明一下应用场景，在线考试系统有自动交卷和手工交卷，结构大致如下   　　   function handInAuto(){     doHandIn();
深入解析synchronized实现原理，如何保证原子性、有序性和可见性？
qq_44799530的博客
06-11 2365
前言 这篇文章主要介绍synchronized底层实现，还有它是如何保证原子性、有序性和可见性的。 在进入正题之前，举个小栗子： 看代码： public class Demo { public synchronized void method1() { System.out.println("Hello, do method1."); //模拟网络IO try { Thread.sleep(50);
JAVA 同步之 synchronized 修饰方法
weixin_33742618的博客
09-14 358
在JAVA多线程编程中，将需要并发执行的代码放在Thread类的run方法里面，然后创建多个Thread类的对象，调用start()方法，线程启动执行。 当某段代码需要互斥时，可以用 synchronized 关键字修饰，这里讨论 synchronized 关键字修饰方法时，是如何互斥的。 synchronized 修饰方法时锁定的是调用该方法的对象。它...
线程安全性 - 原子性 - 锁 synchronize
秋夫人
01-12 674
原子性 - 锁 原子性：互斥性。能保证同一时刻只有一个线程操作的，除了atomic包内的类,另个锁。 锁： synchronized, 锁关键字，依赖jvm实现，这个关键字作用对象的作用范围内，同一时刻只能有一个线程操作的， Lock:依赖特殊的cpu指令，代码实现，ReentrantLock synchronized synchronized同步锁，修饰4中对象 （1）修饰一个代码块,被修饰...
Java多线程安全基础：原子性、可见性和有序性详解
Java多线程安全性基础介绍主要关注的是确保在多线程环境下程序的正确性和一致性。线程安全是一种编程实践，它保证了多个线程同时访问共享资源时的结果是预期的，避免了竞态条件、指令重排序等问题。 **1. ** **线程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值