synchronized

最新推荐文章于 2025-05-17 17:00:09 发布
最新推荐文章于 2025-05-17 17:00:09 发布
阅读量137 收藏
点赞数
文章标签： java jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_59749255/article/details/126490667
版权

synchronized原理

       引入锁机制以解决线程安全问题:
悲观锁:当存在多个线程操作共享数据时，需要保证同一时刻有且只有一个线程在操作共享数据，其他线程必须等到该线程处理完数据后再进行
乐观锁:CAS  compare and set

       在添加synchronized关键字后就可以保证在一个时刻上只有一个线程在调用某个方法或者代码块，不会出现并发的情形，达到排队执行的效果。 

       在Java中synchronized可保证在同一个时刻，只有一个线程可以执行某个方法或者某个代码块(主要是对方法或者代码块中存在共享数据的操作)，同时还应该注意到synchronized另外一个重要的作用，synchronized可保证一个线程的变化（主要是共享数据的变化）被其他线程所看到（保证可见性，完全可以替代volatile功能），这点确实也是很重要的。 

       对象在内存中存储时可以分为对象头、实例数据和对齐字节三部分。对象头数据一般包含标识字mark word和类型指针klass pointer；实例数据就是具体对象的成员数据，一般按照4B为的单位进行数据存储；最后的对齐字节用于将对象存储的数据凑够8字节的整数倍。

  • Mark Word：默认存储对象的HashCode，分代年龄和锁标志位信息。这些信息都是与对象自身定义无关的数据，所以Mark Word被设计成一个非固定的数据结构以便在极小的空间内存存储尽量多的数据。它会根据对象的状态复用自己的存储空间，也就是说在运行期间Mark Word里存储的数据会随着锁标志位的变化而变化
  • Klass Pointer：对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例。
  • synchronized用的锁是存在Java对象头里的，存在锁对象的对象头的Mark Word中

      synchronized用于实现同步处理，保证共享数据的安全性
      数据有安全性问题的原因：1、共享数据 2、修改数据
      synchronized相对于volatile是重量级的线程安全的方法，可以保证3大特性：原子性、可见性、有序性。
      可以将并发操作转换为串型执行 

锁的三种使用方法

- synchronized同步方法   在方法上添加同步关键字，当前的锁对象为当前对象---对象锁

public class A2 {
	public static void main(String[] args) throws Exception {
		NumOper no = new NumOper(100);
		Thread[] ts = new Thread[4];
		for (int i = 0; i < 2; i++) {
			ts[i * 2] = new Thread(() -> {
				for (int k = 0; k < 50; k++)
					no.add();
			});
			ts[i * 2].start();
			ts[i * 2 + 1] = new Thread(() -> {
				for (int k = 0; k < 50; k++)
					no.sub();
			});
			ts[i * 2 + 1].start();
		}
		for (Thread tmp : ts)
			tmp.join();
		System.out.println("Main:" + no.getNum());
	}
}

/*
 * 以new出来的NumOper对象充当锁，当前对象内的所有synchronized方法在不同线程调用时互斥，
 * 但是可以直接访问非synchronized方法。注意synchronized允许持有锁的线程重入
 */
class NumOper {
	private int num;

	public NumOper(int num) {  //synchronized不能添加在构造器上
		this.num = num;
	}

	public synchronized void add() {
		System.out.println(Thread.currentThread() + "....add...begin:" + this.num);
		this.num++;
		sub();
		System.out.println(Thread.currentThread() + "....add...end" + this.num);
	}

	public synchronized void sub() {
		System.out.println(Thread.currentThread() + "....sub...begin" + this.num);
		this.num--;
		System.out.println(Thread.currentThread() + "....sub...end" + this.num);
	}

	public int getNum() {
		return this.num;
	}
}

- synchronized同步静态方法  以当前类Class对象作为锁---类锁
        针对一个类一般只会存储一个

public class A3 {
	public static void main(String[] args) {
		for (int i = 0; i < 5; i++) {
			new Thread(() -> {
				for (int k = 0; k < 10; k++)
					new S3();
			}).start();
		}
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(S3.getCounter());
	}
}

class S3 {
	private static int counter = 0;

	public S3() {
		add();
	}

	private synchronized static void add() {
		System.out.println(Thread.currentThread() + "开始创建操作" + counter);
		counter++;
		eee();
		System.out.println(Thread.currentThread() + "完成创建操作" + counter);
	}
	public synchronized static void eee() {
		
	}
	public static int getCounter() {
		return counter;
	}
}

- synchronized同步代码块   自定义对象充当锁

public class A {
	public static void main(String[] args) {
		for(int i=0;i<3;i++) {
			Thread t1=new MyThread("第"+(i+1)+"个售票窗口");
			t1.start();
		}
	}
}

class MyThread extends Thread {
	private String name;
	private static int counter = 20;
	private final static String LOCK="lock1";

	public MyThread(String name) {
		this.name = name;
	}

	@Override
	public void run() {
		while (counter > 0) {
			try {
				sleep(100);// 模拟售票过程，加剧出错的可能性
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			
			synchronized (LOCK) {
				if (counter > 0) {
					System.out.println(this.name + "售出第" + counter + "号票");
//					synchronized (LOCK) {
						counter--;
//					}
				} else {
					System.out.println("票已经售尽!");
				}
			}
		}
	}
}

锁的使用注意事项

1：使用类锁，所以不管new了多少个对象，都可以得到互斥的效果

​

public class A4 {
	public static void main(String[] args) {
		new Thread(() -> {
			for (int i = 0; i < 100; i++) {
				S4 ss = new S4();
				ss.pp1();
			}
		}).start();
		new Thread(() -> {
			for (int i = 0; i < 100; i++) {
				S4 ss = new S4();
				ss.pp1();
			}
		}).start();
	}
}

class S4 {
	public synchronized static void pp1() {
		System.out.println(Thread.currentThread() + "...begin...");
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread() + "...end...");
	}

	public void pp2() {
	}
}
​

2：使用的是对象锁，所以只能new一个对象，才可以得到互斥的效果。如果创建多个则不能达到互斥的目的

public class A41 {
	public static void main(String[] args) {
		S41 ss = new S41();
		new Thread(() -> {
//			S41 ss=new S41();
			for (int i = 0; i < 100; i++) {
//				S41 ss = new S41();
				ss.pp2();
			}
		}).start();
		new Thread(() -> {
//			S41 ss=new S41();
			for (int i = 0; i < 100; i++) {
//				S41 ss = new S41();
				ss.pp2();
			}
		}).start();
	}
}

class S41 {
	public synchronized static void pp1() {
		System.out.println(Thread.currentThread() + "pp1...begin...");
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread() + "pp1...end...");
	}

	public synchronized void pp2() {
		System.out.println(Thread.currentThread() + "pp2...begin...");
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread() + "pp2...end...");
	}
}

3：使用的是不同的锁，所以thread0和thread1不能达到互斥的目的

public class A42 {
	public static void main(String[] args) {
		S42 ss = new S42();
		new Thread(() -> {
			for (int i = 0; i < 100; i++) {
				ss.pp2(); //非static  -- 对象锁  ss
			}
		}).start();
		new Thread(() -> {
			for (int i = 0; i < 100; i++) {
				ss.pp1();//static  --类锁   S42.class
			}
		}).start();
	}
}

class S42 {
	public synchronized static void pp1() {
		System.out.println(Thread.currentThread() + "pp1...begin...");
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread() + "pp1...end...");
	}

	public synchronized void pp2() {
		System.out.println(Thread.currentThread() + "pp2...begin...");
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread() + "pp2...end...");
	}
}

synchronized锁原理分析（一、从Java对象头看synchronized锁的状态）
12-21
《深入剖析synchronized锁原理——从Java对象头的角度》 synchronized关键字在Java中扮演着重要的角色，它是Java实现同步的基础，确保了多线程环境下的数据一致性。不同于基于JDK实现的Lock接口（如ReentrantLock）...
加不加 synchronized 有什么区别？
12-21
在Java编程语言中，`synchronized`关键字是一个非常重要的概念，它主要用于实现线程同步，以确保多线程环境下的数据一致性与安全性。当我们讨论在方法或者代码块中是否使用`synchronized`时，主要涉及以下几个方面的...
【多线程与高并发】- synchronized锁的认知
qq_43843951的博客
02-19 23万+
synchronized 是 Java 语言的一个关键字，它允许多个线程同时访问共享的资源，以避免多线程编程中的竞争条件和死锁问题。
Synchronized
qq_34591246的博客
02-26 857
synchronized
深入理解Java并发之synchronized实现原理
zejian的博客
06-04 40万+
【版权申明】未经博主同意，谢绝转载！（请尊重原创，博主保留追究权） http://blog.youkuaiyun.com/javazejian/article/details/72828483 出自【zejian的博客】 关联文章： 深入理解Java类型信息(Class对象)与反射机制 深入理解Java枚举类型(enum) 深入理解Java注解类型(@Annotation) 深...
【事务与锁】当Transactional遇上synchronized
qq_43843951的博客
03-15 22万+
最近工作中遇到某些七七八八的问题，就是与事务和锁、并发都有着紧密联系相关的问题所在。主要情况是：通过调用方法获取编号，而这个编号是递增有序的，并且存在于数据库中，简单理解就是需要用到这种编号(以下称任务编号)，需要从数据库获取出来，在+1最为本次需要的编号，然后在存回数据库中，提供下次使用。直观来看是没得问题的，但是，可能在某次并发的时候出现编号相同，着属实很令人头疼，在经过领导的指导下是完美的解决了，接下来复盘一下。
Java中Synchronized的用法
热门推荐
阳光日志
06-24 50万+
synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种： 1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； 2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 3.修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象； 4..
synchronized详细
LiuYong_01的博客
08-28 1405
synchronized是Java中实现线程同步的关键字，用于保护共享资源的访问，确保在多线程环境中同一时间只有一个线程能够访问特定的代码段或方法。它提供了互斥性，可见性和有序性三个基本特征，确保了线程间操作的原子性和数据的一致性。互斥性：当一个线程进入了synchronized代码块或方法时，其他视图进入该同步区域的线程必须等待，直至拥有锁的线程执行完毕并释放锁。这确保了在同一时间只能有一个线程访问共享资源，避免了竞态条件和数据不一致的问题。
Synchronized详解
qq_50839597的博客
09-04 1790
在JVM中，monitorenter和monitorexit字节码都是依赖于底层操作系统的Mutex Lock实现的，需用将当前线程挂起，并从用户态切换到内核态，这个过程的代价非常昂贵，然后实际情况是，很多时候同步方法都运行在无锁竞争的单线程的情况下，每次再调用操作系统就得不偿失了。如果持有锁的线程很快就释放了锁，那么自旋的效率就非常好，反之，自旋的线程就会白白消耗掉处理的资源，这样反而会带来性能上的浪费。如果设置了，则尝试使用CAS将对象头的偏向锁指向当前线程，当到达全局安全点，获得偏向锁的线程被挂起，
synchronized详解
codedot
01-09 8万+
synchronized详解
synchronized 关键字
buhuisuanfa的博客
12-12 4060
线程进入一个层锁，第二次加锁的时候会组设等待，直到第一次锁释放，才能获取第二个锁，但是我们会在锁对象里记录一下，当前的锁是那个对象是那个线程持有的，如果加锁线程和持有线程是同一个，就放过，否则阻塞。因为在加锁的同时，会带来额外的时间开销，有些情况下，不使用多线程，不会面临线程安全问题，所以我们的一些集合并没有加锁，因此，我们在多线程情况下使用这些集合时，可以手动加锁。两个线程两把锁，t1,t2现针对锁A，锁B加锁，再去获取对方的锁，双方都不愿意让步，就会造成死锁问题。
透彻理解Java中Synchronized（对象锁）和Static Synchronized（类锁）的区别
08-27
Java 中 Synchronized（对象锁）和 Static Synchronized（类锁）的区别 Synchronized 和 Static Synchronized 是 Java 中两种同步机制，它们都用于解决多线程并发访问的安全问题。然而，它们之间存在着本质的区别。...
Java中synchronized正确使用方法解析
08-25
Java 中 synchronized 正确使用方法解析 Java 中 synchronized 关键字是解决线程安全问题的重要手段，它可以确保在多线程环境下，共享资源的访问安全性。本文将详细介绍 Java 中 synchronized 的正确使用方法，通过...
Synchronized 和 Lock 的区别和使用场景
01-20
本文将深入探讨两种主要的锁机制：`synchronized`关键字和`Lock`接口，以及它们各自的特点、应用场景和使用方式。 一、Synchronized `synchronized`是Java中的一个内置关键字，用于提供线程安全。它的主要作用是...
使用Spring Boot和Spring Security构建安全的RESTful API
intwei的博客
05-17 746
本文详细介绍了如何使用Spring Boot和Spring Security构建安全的RESTful API，并结合JWT实现身份验证与授权。通过实际代码示例，帮助开发者快速上手。完整的项目代码可以在GitHub上找到。
上集：一个前端的血泪复仇记 —— 静态部署的胜利
最新发布
十步杀一人-千里不留行
05-17 1229
在《上集：一个前端的血泪复仇记 —— 静态部署的胜利》中，作者分享了在部署一个前后端分离的小项目时遇到的挑战和解决方案。项目后端使用Spring Boot，前端使用Next.js。在部署过程中，前端静态资源的处理成为主要难题。作者通过将Next.js生成的静态文件直接放入Spring Boot的static目录，简化了部署流程。然而，Spring Security的默认配置阻止了对这些静态资源的访问，导致403错误。通过调整SecurityConfig和WebConfig，作者成功解决了这一问题。此外，前端
WEB安全--Java安全--CC1利用链
m0_74800552的博客
05-14 1534
CC1利用链的原理与构建方式
HashSet
weixin_51718998的博客
05-15 869
（1）HashSet的去重机制：hashCode()+equals()，底层先通过存入对象，进行运算得到一个hash值，通过hash值得到对应的索引，如果发现table索引所在的位置，没有数据，就直接存放，如果有数据，就进行equals[遍历]比较，如果比较后，不相同就加入，否则就不加入。在开发中，选择什么集合实现类，主要取决于业务操作特点，然后根据集合实现类特性进行选择，分析如下：1）先判断存储的类型（一组对象[单列]或一组键值对[双列]）map.put("no1","hahaha");
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值