Synchronized锁1

最新推荐文章于 2023-05-17 12:36:02 发布
最新推荐文章于 2023-05-17 12:36:02 发布
阅读量497 收藏
点赞数 2
文章标签： java jvm servlet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tiger_root/article/details/126589447
版权

 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...");
	}
}
一介烂人ぶ谩骂随心
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
不同方面浅浅认识一下 Synchronized
m0_71777195的博客
03-10 211
synchronized是Java中非常重要的同步机制，它可以保证多个线程之间的安全协作，但在使用时需要考虑锁的粒度和性能问题，同时也有一些锁优化的技巧可以使用。除了synchronized之外，Java中还有许多替代方案可以实现线程同步，包括Lock、Atomic、ConcurrentHashMap等。在实际应用中，需要根据具体的场景选择适合的同步机制来保证程序的正确性和性能。会在后续讲解不同锁结构。
Java并发 synchronized锁住的内容解析
08-25
Java并发synchronized锁住的内容解析 Java并发synchronized锁住的内容解析是Java并发编程中的一种重要机制，用于解决多线程并发访问同一个资源时可能出现的线程安全问题。通过使用synchronized关键字，可以锁住当前...
【Java多线程】synchronized同步语句块
热门推荐
一定要站在自己热爱的生活里闪闪发光
10-11 4万+
synchronized方法是对当前对象进行加锁，而synchronized代码块是对某一个对象进行加锁。 1.synchronized方法的弊端 在使用synchronized关键字来声明方法的时，线程需要排队执行，运行时间较长。 2.synchronized同步代码块的使用 当两个并发线程访问同一个对象object中的synchronized(this)同步代码时，一段时间内只能有一个线程被执行，另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。 下面通过一个示例来说..
Java中synchronized锁的优化
一名Java语言狂热分子。
05-04 193
在Java中，synchronized是一种最基本的线程同步机制，通过对临界区代码块加锁来保证数据的正确性和一致性，但在高并发的情况下，使用synchronized会导致性能问题。为了解决这个问题，Java对synchronized锁进行了优化，主要包括无锁状态、偏向锁、轻量级锁、重量级锁四种方式。
有趣的漫画版 HashMap，25岁大爷都能看懂
古时的风筝
06-22 1486
我是风筝，公众号「古时的风筝」，一个兼具深度与广度的程序员鼓励师，一个本打算写诗却写起了代码的田园码农！ 文章会收录在 JavaNewBee 中，更有 Java 后端知识图谱，从小白到大牛要走的路都在里面。回复「666」有高清学习路线图。 因为写文章的过程中画了不少的图，所以，我想，能不能用长图的形式展现一次呢，结果图片熬夜做了半天，最后出来的效果不是很好，哎，审美缺失吧。之后会有详细的文字源码解析版放出，敬请各位看官关注。 在 Java 中，最常用的数据类型是 8 中基本类型以及他们的包装类型以及字符.
java static 对象加锁_Java学习——单例模式
weixin_39963819的博客
12-10 296
GOF四人合著出版了一本名为Design Patterns - Elements of Reusable Object-Oriented Software（中文译名：设计模式 - 可复用的面向对象软件元素）的书，共有23种设计模式，而这些设计模式又分为3大类：1、创建型模式2、结构型模式3、行为型模式单例模式属于第一种，是创建型模式什么是单例模式呢？what？ 答：顾名思义，就是单一的...
Java中synchronized的优化
飞鱼的博客
05-17 525
为了实现高效并发，虚拟机对 synchronized 做的一系列的锁优化措施。包括：适应性自旋、锁消除、锁粗化、轻量级锁、偏向锁。
synchronized枷锁实例
07-05
本文将深入探讨`synchronized`关键字的用法，包括类锁、对象锁、方法锁以及它们之间的关系。 **类锁（Class Lock）** 类锁是通过类的Class对象实现的，当一个线程访问类的静态 synchronized 方法或同步代码块时，就...
Java Synchronized锁失败案例及解决方案
08-19
Java Synchronized锁失败案例及解决方案 Java Synchronized锁是一种同步机制，用于解决多线程并发访问共享资源的问题。它通过锁机制来实现线程之间的同步，防止多个线程同时访问同一个资源，从而避免了线程安全问题...
Java synchronized锁升级jol过程详解
08-19
Java synchronized锁升级jol过程详解 Java synchronized锁升级jol过程详解是Java并发编程中一个重要的概念，了解锁升级过程对Java开发者来说非常重要。本文将通过示例代码详细介绍Java synchronized锁升级jol过程...
Java使用synchronized实现互斥锁功能示例
08-19
Java使用synchronized实现互斥锁功能示例 在Java编程语言中，synchronized关键字是实现互斥锁功能的主要手段。互斥锁是一种机制，用于控制多个线程访问共享资源的顺序，从而避免因为资源竞争而导致的程序错误。在...
「Synchronized与锁升级」锁优化的背景及性能的变化
frozenpenguin的博客
09-22 1570
在Java早期版本中，synchronized属于重量级锁，效率低下，因为监视器锁（monitor）是依赖于底层的操作系统的Mutex Lock来实现的，挂起线程和恢复线程都需要转入内核态去完成，阻塞或唤醒一个Java线程需要操作系统切换CPU状态来完成，这种状态切换需要耗费处理器时间，如果同步代码块中内容过于简单，这种切换的时间可能比用户代码执行的时间还长”，时间成本相对较高，这也是为什么早期的synchronized效率低的原因 .
详解synchronized锁的各种用法及注意事项
Java知音
12-14 1716
1 前言本文主要通过简单的demo来阐述synchronized锁的各种用法以及使用synchronized锁的相关注意事项，记录下来同时也方便自己记忆。synchronized锁是jvm...
synchronized 的弊端： 耗时过长解决方法：用同步代码块解决时间太长的弊端，但是同步代码块也是有弊端的
qq_20610631的博客
08-08 5989
1 耗时过长  package commonutils; public class CommonUtils { public static long beginTime1; public static long endTime1; public static long beginTime2; public static long endTime2; } package mytas...
性能优化——Synchronized同步锁的优化方法
qq_36589864的博客
08-20 628
在并发编程中，多个线程访问同一个共享资源时，我们必须考虑如何维护数据的原子性。在 JDK1.5 之前，Java 是依靠 Synchronized 关键字实现锁功能来做到这点的。 Synchronized 是 JVM 实现的一种内置锁，锁的获取和释放是由 JVM 隐式实现。 到了 JDK1.5 版本，并发包中新增了 Lock 接口来实现锁功能，它提供了与 Synchronized 关键字类似的同步功能，只是在使用时需要显示获取和释放锁。 Lock 同步锁是基于 Java 实现的，而 Syn..
【JUC】10. synchronized与锁升级
沉迷写代码的程序猿的博客
10-23 750
synchronized锁升级过程总结:一句话，就是先自旋，不行再阻塞。实际上是把之前的悲观锁(重量级锁)变成在一定条件下使用偏向锁以及使用轻量级(自旋锁CAS)的形式synchronized在修饰方法和代码块在字节码上实现方式有很大差异，但是内部实现还是基于对象头的MarkWord来实现的。JDK1.6之前synchronized使用的是重量级锁，JDK1.6之后进行了优化，拥有了无锁->偏向锁->轻量级锁->重量级锁的升级过程，而不是无论什么情况都使用重量级锁。
synchronized原理剖析与优化
一条小黑龙的博客
10-28 1095
并发编程的三个问题 可见性 原子性 有序性 缓存 CPU的运算速度和内存的访问速度相差比较大。这就导致CPU每次操作内存都要耗费很多等待时间。内存的读写速度成为了计算机运行的瓶颈。于是就有了在CPU和主内存之间增加缓存的设计。最靠近CPU的缓存称为L1，然后依次是L2，L3和主内存，CPU缓存模型如图下图所示： CPU Cache分成了三个级别: L1， L2， L3。级别越小越接近CPU，速度也更快，同时也代表着容量越小。1. L1是最接近CPU的，它容量最小，例如32K，速度最快，每个核上都有一个
同步（synchronized）对程序性能的影响！
swingboat
11-10 889
在使用多线程时，可能会访问一些全局的数据，这时必然会使用同步机制来使程序按照一定顺序来执行，这样程序的性能也会下降。所以一定要慎用同步，正确用同步。看下面的程序         int curIndex = 0;        AuditQueueEntry aqe;        synchronized (localCriticalSection) {                  whi...
synchronized 对性能的影响
arkblue的专栏
11-01 4596
private static Object lock = new Object(); public static void main(String[] args) { for (int k = 0; k < 10; k++) { long start = System.currentTimeMillis(); for (int j = 0; j < 10000000;
synchronized锁粒度
最新发布
09-23
synchronized锁粒度指的是锁的范围和精细度。在Java中，synchronized关键字可以用于不同的地方，包括方法、代码块和静态方法等。不同的用法会导致不同的锁粒度。 具体来说，synchronized方法是对整个方法进行加锁，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值