Synchronized锁1

最新推荐文章于 2024-11-27 15:08:39 发布
原创 最新推荐文章于 2024-11-27 15:08:39 发布 · 583 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #jvm #servlet

本文深入探讨了Java中的synchronized关键字，包括其语法形式、应用场景及如何通过实例代码演示同步方法和同步代码块的使用，帮助读者理解并发编程中的数据安全性和线程间的互斥原理。

 Synchronized

在java语言中存在两种内建的synchronized语法：synchronized语句和synchronized方法。synchronized将并行改为串行，当然会影响程序的执行效率，执行速度会受到影响。其次synchronized操作线程的堵塞，也就是由操作系统控制CPU的内核进行上下文的切换，这个切换本身也是耗时的。所以使用synchronized关键字会降低程序的运行效率。 

三个售票窗口同时出售20张票

public class Test1 {
	public static void main(String[] args) {
		for(int i=1;i<=3;i++) {
			new 售票线程(i+"号窗口").start();
		}
	}
}


class 售票线程 extends Thread{
	private String name;
	private static Integer count=20;//票池，static保证多个线程对象共享一个票池
	private static final String aaa="bbbb";
	public 售票线程(String name) {
		this.name = name;
	}
	@Override
	public void run() {
		while(count>0) {
//			System.out.println(this.name+count+"开始售票");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			synchronized (aaa) {
				if(count>0) {
					System.out.println(this.name+"售出第 "+count+" 号票");
					count--;
//					System.out.println(this.name+":"+count);
				}else {
					System.out.println(this.name+"票已售尽");
				}
//				System.out.println(this.name+count+"结束售票");
			}
		}
	}
}

Synchronized用于实现同步处理，保证共享数据的安全性


数据有安全性问题的原因：1、共享数据 2、修改数据

Synchronized相对于volatile是重量级的线程安全的方法，可以保证3大特性：原子性、可见性、有序性


synchronized将并行改为串行
         -用于静态方法，锁对象为当前类

                public synchronized static void pp(){}
        -用于非静态方法，锁对象为当前类的对象
                public synchronized void pp(){}
        -用于代码块，锁对象为指定的对象  该对象可以自定义
                synchronized(obj){}

同步代码块

import java.util.concurrent.locks.Lock;

//同步代码块
public class A {
	public static void main(String[] args) {
		for(int i=1;i<=3;i++) {
			new MyThread(i+"号窗口").start();
		}
	}
}

class MyThread extends Thread{
	private String name;
	private static int counter=20;
	private static final String LOCK="bbbb";
	
	public MyThread(String name) {
		this.name=name;
	}
	
	@Override
	public void run() {
		while(counter>0) {
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			synchronized (LOCK) {//锁的数量一定要比资源少，要把资源锁住，用name不可以，因为name是3个窗口，不能锁住，锁有一把；只要是引用类型都可以，
				if(counter>0) {
					System.out.println(this.name+"售出第"+counter+"号票");
					synchronized (LOCK) {
						counter--;						
					}
					System.out.println(this.name+":"+counter);
				}else {
					System.out.println(this.name+":"+"票已售尽");
				}
			}
		}
	}
}

同步方法

public class A2 {
	public static void main(String[] args) throws Exception {
		NumOper no=new NumOper(100);
		Thread[] th=new Thread[4];
		for (int i = 0; i < 2; i++) {
			th[i*2]=new Thread(() -> {
				for(int k=0;k<50;k++) {
					no.add();
				}
			});
			th[i*2].start();
			th[i*2+1]=new Thread(() -> {
				for(int k=0;k<50;k++) {
					no.sub();
				}
			});
			th[i*2+1].start();
		}
		for(Thread tmp:th)
			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() + "Thread......begin" + this.num);
		this.num++;
//		sub();
		System.out.println(Thread.currentThread() + "Thread......end" + this.num);
	}

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

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

同步静态方法

统计指定类的创建次数 ，代码如下：

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(10000);
		} 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() {//static 不可以用this
		System.out.println(Thread.currentThread()+"开始创建操作"+counter);
		counter++;
		System.out.println(Thread.currentThread()+"完成创建操作"+counter);
	}
	public static int getCounter() {
		return counter;
	}
}

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

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

使用的是对象锁，所以只能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<20;i++) {
//			S41 ss=new S41();
			ss.pp2();
			}
		}).start();
		new Thread(()->{
//			S41 ss=new S41();
			for(int i=0;i<20;i++) {
//			S41 ss=new S41();
			ss.pp2();
			}
		}).start();
	}
}
//类S4为锁对象
class S41{
	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 synchronized void pp2() {
		System.out.println(Thread.currentThread()+"...begin...");
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread()+"...end...");
	}
	public synchronized void pp3() {
		System.out.println(Thread.currentThread()+"...begin...");
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread()+"...end...");
	}
}

使用的是不同的锁，所以thread0和thread1不能达到互斥的效果。

public class A42 {
	public static void main(String[] args) {
		S42 ss=new S42();
		new Thread(()->{
//			S41 ss=new S41();
			for(int i=0;i<20;i++) {
//			S41 ss=new S41();
//			ss.pp2();//非static方法 --对象锁  ss
			ss.pp3();
			}
		}).start();
		new Thread(()->{
//			S41 ss=new S41();
			for(int i=0;i<20;i++) {
//			S41 ss=new S41();
			ss.pp1();//static方法  --类锁  S42.class
			ss.pp4();
			}
		}).start();
	}
}
//类S4为锁对象
class S42{
	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 synchronized void pp2() {
		System.out.println(Thread.currentThread()+"...begin...");
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread()+"...end...");
	}
	public synchronized static void pp3() {
		System.out.println(Thread.currentThread()+"...begin...");
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread()+"...end...");
	}
	public synchronized static void pp4() {
		System.out.println(Thread.currentThread()+"...begin...");
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread()+"...end...");
	}
}

锁对象不一样会导致锁不住，一个是类锁，一个是对象锁

public class A44 {
	public static void main(String[] args) {
		S44 ss=new S44();
		new Thread(()->{
//			S44 ss=new S44();
			for(int i=0;i<20;i++) {
//			S41 ss=new S41();
//			ss.pp2();//非static方法 --对象锁  ss
			ss.pp3();
			}
		}).start();
		new Thread(()->{
//			S44 ss=new S44();
			for(int i=0;i<20;i++) {
//			S41 ss=new S41();
			ss.pp2();//非static方法 --对象锁  ss
			}
		}).start();
		new Thread(()->{
//			S44 ss=new S44();
			for(int i=0;i<20;i++) {
//			S41 ss=new S41();
			ss.pp1();//static方法  --类锁  S42.class
			}
		}).start();
		new Thread(()->{
//			S44 ss=new S44();
			for(int i=0;i<20;i++) {
//			S41 ss=new S41();
				ss.pp4();
			}
		}).start();
	}
}
//类S4为锁对象
class S44{
	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 synchronized void pp2() {
		System.out.println(Thread.currentThread()+"...begin..."+Thread.currentThread().getName());
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread()+"...end..."+Thread.currentThread().getName());
	}
	public synchronized static void pp3() {
		System.out.println(Thread.currentThread()+"...begin...");
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread()+"...end...");
	}
	public synchronized static void pp4() {
		System.out.println(Thread.currentThread()+"...begin...");
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread()+"...end...");
	}
}
Java并发_第六篇：synchronized的缺陷，Lock的诞生
毛毛的专栏
08-02 1132
文章目录一、前言辨析Lock接口、ReentrantLock类、ReadWriteLock接口、ReentrantReadWriteLock类二、synchronized的缺陷三、java.util.concurrent.Lock包下常用的类3.1 Lock接口及其四个方法的使用3.1.1 Lock接口的lock()3.1.2 Lock接口的tryLock()3.1.2 Lock接口的lockInterruptibly()3.2 ReentrantLock类及其四个方法的使用3.2.1 ReentrantL
不同方面浅浅认识一下 Synchronized
m0_71777195的博客
03-10 297
synchronized是Java中非常重要的同步机制，它可以保证多个线程之间的安全协作，但在使用时需要考虑锁的粒度和性能问题，同时也有一些锁优化的技巧可以使用。除了synchronized之外，Java中还有许多替代方案可以实现线程同步，包括Lock、Atomic、ConcurrentHashMap等。在实际应用中，需要根据具体的场景选择适合的同步机制来保证程序的正确性和性能。会在后续讲解不同锁结构。
为什么有sychronized效率会低
Li2992673708的博客
08-30 708
关键字通常是对整个方法或代码块进行同步，这可能导致锁的粒度过大，即使只有部分代码需要同步，其他线程也需要等待锁的释放。竞争与阻塞：当多个线程同时竞争同一个锁时，只有一个线程能够获取到锁，其他线程会被阻塞。串行执行：由于同一时间只有一个线程能够获取锁并执行同步代码块，其他线程必须等待，这导致并发性能受限，无法充分利用多核处理器的优势。JVM 在锁的实现上进行了优化，例如偏向锁、轻量级锁和重量级锁等，以提高。包中的锁或并发集合类，它们提供了更细粒度的控制和更好的性能。，在多线程并发的情况下，
有趣的漫画版 HashMap，25岁大爷都能看懂
古时的风筝
06-22 1556
我是风筝，公众号「古时的风筝」，一个兼具深度与广度的程序员鼓励师，一个本打算写诗却写起了代码的田园码农！ 文章会收录在 JavaNewBee 中，更有 Java 后端知识图谱，从小白到大牛要走的路都在里面。回复「666」有高清学习路线图。 因为写文章的过程中画了不少的图，所以，我想，能不能用长图的形式展现一次呢，结果图片熬夜做了半天，最后出来的效果不是很好，哎，审美缺失吧。之后会有详细的文字源码解析版放出，敬请各位看官关注。 在 Java 中，最常用的数据类型是 8 中基本类型以及他们的包装类型以及字符.
Java中synchronized锁的优化
一名Java语言狂热分子。
05-04 322
在Java中，synchronized是一种最基本的线程同步机制，通过对临界区代码块加锁来保证数据的正确性和一致性，但在高并发的情况下，使用synchronized会导致性能问题。为了解决这个问题，Java对synchronized锁进行了优化，主要包括无锁状态、偏向锁、轻量级锁、重量级锁四种方式。
synchronized锁原理分析（一、从Java对象头看synchronized锁的状态）
12-21
《深入剖析synchronized锁原理——从Java对象头的角度》 synchronized关键字在Java中扮演着重要的角色，它是Java实现同步的基础，确保了多线程环境下的数据一致性。不同于基于JDK实现的Lock接口（如ReentrantLock）...
synchronized枷锁实例
07-05
本文将深入探讨`synchronized`关键字的用法，包括类锁、对象锁、方法锁以及它们之间的关系。 **类锁（Class Lock）** 类锁是通过类的Class对象实现的，当一个线程访问类的静态 synchronized 方法或同步代码块时，就...
Java并发 synchronized锁住的内容解析
08-25
Java并发synchronized锁住的内容解析 Java并发synchronized锁住的内容解析是Java并发编程中的一种重要机制，用于解决多线程并发访问同一个资源时可能出现的线程安全问题。通过使用synchronized关键字，可以锁住当前...
透彻理解Java中Synchronized（对象锁）和Static Synchronized（类锁）的区别
08-27
Java 中 Synchronized（对象锁）和 Static Synchronized（类锁）的区别 Synchronized 和 Static Synchronized 是 Java 中两种同步机制，它们都用于解决多线程并发访问的安全问题。然而，它们之间存在着本质的区别。...
synchronized 锁升级
weixin_37782784的博客
11-27 1095
锁升级是 Java 用来优化锁的机制。在无竞争的情况下，使用偏向锁和轻量级锁，以减少不必要的开销。一旦有线程竞争，锁会升级为重量级锁，保证线程安全，但会带来性能上的代价。这就是锁升级的基本概念，目的是在不同的竞争情况下，动态调整锁的类型，从而提供最佳的性能和线程安全性。
synchronized
xurc1996的博客
12-20 573
synchronized的三种应用方式 修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁 修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁 修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。 synchronized底层语义原理 ava 虚拟机中的同步(Synchronization)基于进入和退出管程(Monitor)对象实现， 无论是显式同步(有明确的 monitorenter 和 monitorexit 指令,即同步代
java synchronized 效率_（十一）java中synchronized和ReentrantLock有什么不同？ReentrantLock优势是什么？synchronized性能差，为什么...
weixin_30921373的博客
03-06 791
------------------------------版本一---------------------------------1.区别：1)Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；2)synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock...
synchronized性能很差？synchronized详解
wswpomos的博客
10-06 3626
synchronized它能用来同步方法和代码块，那 synchronized 到底锁的是什么呢？，Java 中的每一个对象都可以作为一个锁。Class 对象是一种特殊的 Java 对象，代表了程序中的类和接口。Java 中的每个类型（包括类、接口、数组以及基础类型）在 JVM 中都有一个唯一的 Class 对象与之对应。这个 Class 对象被创建的时机是在 JVM 加载类时，由 JVM 自动完成。
java static 对象加锁_Java学习——单例模式
weixin_39963819的博客
12-10 373
GOF四人合著出版了一本名为Design Patterns - Elements of Reusable Object-Oriented Software（中文译名：设计模式 - 可复用的面向对象软件元素）的书，共有23种设计模式，而这些设计模式又分为3大类：1、创建型模式2、结构型模式3、行为型模式单例模式属于第一种，是创建型模式什么是单例模式呢？what？ 答：顾名思义，就是单一的...
Java中synchronized的优化
飞鱼的博客
05-17 607
为了实现高效并发，虚拟机对 synchronized 做的一系列的锁优化措施。包括：适应性自旋、锁消除、锁粗化、轻量级锁、偏向锁。
多线程——深入剖析 Synchronized
qq_42583242的博客
08-25 684
多线程——Synchronized 详解 文章目录多线程——Synchronized 详解一、Synchronzized 的三种使用方式1、Synchronzized 作用于实例方法2、Synchronized 作用于静态方法3、Synchronized 作用于代码块二、Synchronized 的底层语义原理1、Synchronized 的语义原理2、Synchronized 的局限三、JVM 对 Synchronized 的优化1、轻量级锁2、自旋锁3、偏向锁4、总结 Synchronized 的锁升级
synchronized锁优化
疯一样的女子
11-24 325
Java提供了关键字synchronized，方便快捷的解决的线程安全问题。那么synchronized真的就那么好用吗，就没有什么缺点或者需要优化的地方吗？本文就要介绍一下synchronized锁优化。 自旋锁和适应自旋锁 锁消除 锁粗化 偏向锁、轻量级锁、重量级锁 锁的膨胀过程 1. 为什么需要优化？ synchronized监视器锁在互斥...
sychronized底层原理，为什么慢?
di_ko的博客
05-08 631
sychronized是重量级锁：同一时刻有多个线程竞争同一把锁 当多个线程竞争同一把锁时，竞争失败的线程会被阻塞。直到只有锁的线程将锁释放后再次唤醒阻塞的线程 慢的原因： 线程的唤醒和阻塞是一个很耗费CPU资源的操作 优化： 使用自旋锁来获取重量级锁，线程未获得锁后，不是一味地阻塞，而是让线程通过循环不断尝试获取锁 自旋锁的缺点： 若线程占用锁的时间过长，导致CPU资源拜拜浪费 ...
「Synchronized与锁升级」锁优化的背景及性能的变化
frozenpenguin的博客
09-22 1659
在Java早期版本中，synchronized属于重量级锁，效率低下，因为监视器锁（monitor）是依赖于底层的操作系统的Mutex Lock来实现的，挂起线程和恢复线程都需要转入内核态去完成，阻塞或唤醒一个Java线程需要操作系统切换CPU状态来完成，这种状态切换需要耗费处理器时间，如果同步代码块中内容过于简单，这种切换的时间可能比用户代码执行的时间还长”，时间成本相对较高，这也是为什么早期的synchronized效率低的原因 .
synchronized锁
最新发布
06-25
### synchronized锁的工作原理 `synchronized`是Java中用于实现线程同步的关键字，它通过内置的监视器（Monitor）机制来控制多个线程对共享资源的访问。每个对象都有一个与之关联的监视器，当一个线程进入由`synchronized`修饰的代码块或方法时，它必须获取该对象的监视器锁，执行完毕后释放该锁。 在底层实现上，`synchronized`依赖于JVM的`monitorenter`和`monitorexit`指令[^5]。当线程执行到`monitorenter`指令时，会尝试获取对象的锁：如果锁未被占用，则成功获取；如果已被其他线程持有，则当前线程会被阻塞，直到锁被释放。执行完同步代码块后，JVM插入`monitorexit`指令以释放锁。 从Java SE 1.6开始，`synchronized`进行了多项优化，包括偏向锁、轻量级锁、自旋锁等机制，使其性能显著提升。例如，在竞争不激烈的情况下，JVM会尝试使用自旋锁减少线程挂起带来的开销[^4]。此外，JVM还支持锁粗化和锁消除等优化手段，进一步提升性能[^4]。 ### synchronized的使用方法 #### 1. 作用于实例方法 当`synchronized`修饰一个实例方法时，锁住的是调用该方法的对象实例。同一时间只有一个线程可以访问该对象的同步方法。 ```java public class SyncMethod { public synchronized void method() { // 同步代码 } } ``` #### 2. 作用于静态方法 当`synchronized`修饰静态方法时，锁住的是类的Class对象。这意味着所有该类的实例共享同一个锁。 ```java public class SyncStaticMethod { public static synchronized void staticMethod() { // 同步代码 } } ``` #### 3. 作用于代码块（推荐） 更灵活的方式是使用`synchronized`代码块，可以指定锁的对象。这种方式允许更细粒度的锁控制，避免不必要的同步开销。 ```java public class SyncBlock { private Object lock = new Object(); public void method() { synchronized (lock) { // 同步代码 } } } ``` #### 4. 作用于类对象 也可以直接对类加锁，适用于控制整个类级别的并发访问。 ```java public class ClassName { public void method() { synchronized (ClassName.class) { // 同步代码 } } } ``` ### 使用注意事项 - **避免死锁**：多个线程同时请求多个锁时，若顺序不当可能导致死锁。 - **尽量减小同步范围**：过多的同步操作会影响程序性能，应尽可能缩小同步代码的范围。 - **理解锁的作用域**：非静态方法的锁属于对象级别，而静态方法或类的锁属于类级别，两者互不影响。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值