学习整理——Java同步synchronized关键字

最新推荐文章于 2023-04-07 20:41:38 发布
最新推荐文章于 2023-04-07 20:41:38 发布
阅读量478 收藏 1
点赞数
分类专栏： 学习整理 Java 文章标签： 线程 同步
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jeffery_Gong/article/details/52510629
版权

本文总结自：Java线程同步：synchronized锁住的是代码还是对象


结论：

1.synchronized修饰的非static方法其实是在执行方法前，先获取this对象的锁，如果对象锁被其他线程获取了，则进入阻塞状态；

2.synchronized(mutex)修饰的代码段是先获取mutex对象的锁，然后再进入代码段，否则进入阻塞；

3.对于synchronized修饰static方法，如1.差不多，只不过现在是获取该类的class对象，由于一个类只有一个class对象，这时可以真正做到只有一个线程能够执行该代码段；

4.设计同步时，尽量避免直接使用synchronized修饰的非static方法，尽量缩小核心的同步代码段，最大化利用CPU；

5.实例化多个含有synchronized代码段的对象时，可能由于设置的对象锁是非全局的，依然可以有多个线程同时执行同一个代码段。


代码

实例化多个对象，在多个线程里执行synchronized修饰的非static方法。

package cc.appweb.www;

public class SynchTest {
	
	public static void main(String[] args){
		Sy[] sys = new Sy[5];
		WorkThread[] workThread = new WorkThread[5];
		for(int i = 0 ; i < 5 ; i++){
			sys[i] = new Sy();
			workThread[i] = new WorkThread();
			workThread[i].setPara(sys[i], i);
			workThread[i].start();
		}
		try{
			Thread.sleep(2000);
		}catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println("Main Thread end!");
	}
}

class Sy{
	public synchronized void run(int flag){
		System.out.println("Instance "+flag + " run!" );
		try{
			Thread.sleep(1000);
		}catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println("Instance " + flag + " end!" );
	}
}

class WorkThread extends Thread{
	private Sy worker;
	private int flag;
	
	public void setPara(Sy sy, int flag){
		worker = sy;
		this.flag = flag;
	}
	
	@Override
	public void run(){
		worker.run(flag);
	}
}

输出

Instance 0 run!
Instance 1 run!
Instance 3 run!
Instance 4 run!
Instance 2 run!
Instance 0 end!
Instance 1 end!
Instance 2 end!
Instance 4 end!
Instance 3 end!
Main Thread end!
这时多个线程可以同时执行同一个代码段，因为获取的对象锁都不同


将多个Sy实例修改为一个Sy实例

package cc.appweb.www;

public class SynchTest {
	
	public static void main(String[] args){
		//Sy[] sys = new Sy[5];
		Sy sy = new Sy();
		WorkThread[] workThread = new WorkThread[5];
		for(int i = 0 ; i < 5 ; i++){
			//sys[i] = new Sy();
			workThread[i] = new WorkThread();
			workThread[i].setPara(sy, 1);
			workThread[i].start();
		}
		try{
			//Thread.sleep(2000);
			Thread.sleep(20000);
		}catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println("Main Thread end!");
	}
}

class Sy{
	public synchronized void run(int flag){
		System.out.println("Instance "+flag + " run!" );
		try{
			Thread.sleep(1000);
		}catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println("Instance " + flag + " end!" );
	}
}

class WorkThread extends Thread{
	private Sy worker;
	private int flag;
	
	public void setPara(Sy sy, int flag){
		worker = sy;
		this.flag = flag;
	}
	
	@Override
	public void run(){
		worker.run(flag);
	}
}
输出 

Instance 1 run!
Instance 1 end!
Instance 1 run!
Instance 1 end!
Instance 1 run!
Instance 1 end!
Instance 1 run!
Instance 1 end!
Instance 1 run!
Instance 1 end!
Main Thread end!
可见run 和 end变成了成对出现，也就是说其他线程执行run方法时被阻塞了。


生成多个实例，在方法里获取本身对象

package cc.appweb.www;

public class SynchTest {
	
	public static void main(String[] args){
		Sy[] sys = new Sy[5];
		//Sy sy = new Sy();
		WorkThread[] workThread = new WorkThread[5];
		for(int i = 0 ; i < 5 ; i++){
			sys[i] = new Sy();
			workThread[i] = new WorkThread();
			workThread[i].setPara(sys[i], i);
			workThread[i].start();
		}
		try{
			Thread.sleep(2000);
			//Thread.sleep(20000);
		}catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println("Main Thread end!");
	}
}

class Sy{
	public void run(int flag){
		synchronized (this) {
			System.out.println("Instance "+flag + " run!" );
 			try{
                                               Thread.sleep(1000);
                                    }catch (Exception e) {
                                               e.printStackTrace();
                                    }
                                    System.out.println("Instance " + flag + " end!" );
                         }
            }
}

class WorkThread extends Thread{
            private Sy worker;
            private int flag;
            public void setPara(Sy sy, int flag){
                         worker = sy;
                         this.flag = flag;
            }

            @Override
            public void run(){
                         worker.run(flag);
            }
}


</pre><p></p><pre>
输出 

Instance 0 run!
Instance 2 run!
Instance 1 run!
Instance 3 run!
Instance 4 run!
Instance 1 end!
Instance 0 end!
Instance 4 end!
Instance 3 end!
Instance 2 end!
Main Thread end!
依然会同时执行该代码段


生成多个实例，在方法里获取该类的class对象

class Sy{
	public void run(int flag){
		synchronized (Sy.class) {
			System.out.println("Instance "+flag + " run!" );
			try{
				Thread.sleep(1000);
			}catch (Exception e) {
				e.printStackTrace();
			}
			System.out.println("Instance " + flag + " end!" );
		}
	}
}
输出 

Instance 0 run!
Instance 0 end!
Instance 4 run!
Instance 4 end!
Instance 3 run!
Instance 3 end!
Instance 2 run!
Instance 2 end!
Instance 1 run!
Instance 1 end!
Main Thread end!
这时run和end也成对出现了。


测试synchronized static方法

package cc.appweb.www;

public class SynchTest {
	
	public static void main(String[] args){
		WorkThread[] workThreads = new WorkThread[5];
		for(int i = 0; i < 5 ; i++){
			workThreads[i] = new WorkThread(i);
			workThreads[i].start();
		}
		
		try{
			Thread.sleep(10000);
		}catch (Exception e) {
			e.printStackTrace();
		}
	}
}

class Sy{
	
	public synchronized static void staticRun(int flag){
		System.out.println("Instance " + flag + " run!");
		try{
			Thread.sleep(1000);
		}catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println("Instance " + flag + " end!" );
	} 
}

class WorkThread extends Thread{
	
	private int flag;
	public WorkThread(int flag){
		this.flag = flag;
	}
	
	@Override
	public void run(){
		Sy.staticRun(flag);
	}
}
输出 

Instance 0 run!
Instance 0 end!
Instance 3 run!
Instance 3 end!
Instance 4 run!
Instance 4 end!
Instance 2 run!
Instance 2 end!
Instance 1 run!
Instance 1 end!


为了说明synchronized static 方法获取的是类的class对象，可以在方法内添加wait，notify的调用。 

package cc.appweb.www;

public class SynchTest {
	
	public static void main(String[] args){
		WorkThread[] workThreads = new WorkThread[5];
		for(int i = 0; i < 5 ; i++){
			workThreads[i] = new WorkThread(i);
			workThreads[i].start();
		}
		
		try{
			Thread.sleep(10000);
		}catch (Exception e) {
			e.printStackTrace();
		}
	}
}

class Sy{
	
	private static int count=0;
	public synchronized static void staticRun(int flag){
		count ++;
		System.out.println("Instance " + flag + " run!");
		try{
			if(count != 5 )  // 控制线程的等待
				Sy.class.wait();
			Thread.sleep(1000);
		}catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println("Instance " + flag + " end!" );

		Sy.class.notify();
	} 
}

class WorkThread extends Thread{
	
	private int flag;
	public WorkThread(int flag){
		this.flag = flag;
	}
	
	@Override
	public void run(){
		Sy.staticRun(flag);
	}
}
输出 

Instance 0 run!
Instance 3 run!
Instance 2 run!
Instance 1 run!
Instance 4 run!
Instance 4 end!
Instance 0 end!
Instance 3 end!
Instance 2 end!
Instance 1 end!
run和end已经不成对出现，说明获取的就是class对象。


















生成多个实例，在方法里获取本身对象
Jeffery_Gong
关注
专栏目录
Java 的synchronized 的复习 一
Kodulf的专栏
06-29 466
0：只要涉及到同时执行的那么就要就是多线程的，例如四个窗口同时卖票 1：实现多线程的方法有两种一个中是extends Thread，第二种是implement Runnable 如果解释的话就是： 第一种方式，线程任务和线程是绑定在一起的，创建了四个线程就创建了4份资源 第二种方式，线程任务和线程对象进行了分离，只需要创建一个任务对象（只有一个份资源），分别让四个线程去执行。 //第一种
深入理解Java中的synchronized关键字
最新发布
weixin_74268571的博客
06-15 1513
synchronized的详细讲解和底层实现，以及synchronized的同步机制，synchronized的重入和synchronized的异常演示
Java——同步方法_synchronized 关键字
XQC_KKK的博客
10-17 412
同步代码块可以有效解决线程的安全问题,当把共享资源的操作放在 synchronized 定义的区域内时,便为这些操作加了同步锁。 在方法前面同样可以使用 synchronized 关键字来修饰,被修饰的方法为同步方法,它能实现和同步代码块同样的功能,具体语法格式如下: synchronized 返回值类型 方法名([参数1,……]){} 被 synchronized 修饰的方法在某一时刻只允许一个线程访问,访问该方法的其他线程都会发生阻塞,直到当前线程访问完毕后,其他线程才有机会执行方法。 Exampl
线程同步——使用（synchronized）关键字
wu6668的博客
04-14 1807
1.需要线程同步的原因： Java 中允许多线程并行访问，同一时间段内多个线程同时完成各自的操作。但是多个线程同时操作同一个共享数据时，可能会导致数据不准确的问题。 2.线程同步的方法： 可以通过 synchronized 关键字修饰方法实现线程同步，每个Java 对象都有一个内置锁，内置锁会保护使用 synchronized 关键字修饰的方法，要调用该方法就必须先获得锁，否则就处于阻塞状态。 3。synchronized 关键字可以修饰实例方法，也可以修饰静态方法，两者在使用的时候是有区别的。 （1）给实
Java并发编程(5) —— synchronized关键字详解
m0_56602092的博客
04-07 416
在上一篇中我们提到了volatile关键字可通过插入内存屏障的方式来保证变量的可见性（每次使用都到主存中进行读取）和有序性（不允许指令重排序），但是volatile关键字不保证对变量复合操作的原子性，例如i++操作在jvm层面实际上是通过多条指令操作完成，而若用synchronized 关键字将操作代码块包起来，则同一时刻只有一个线程能进入进行操作，这就保证了原子性。 在 Java 早期版本中，synchronized 属于 重量级锁，效率低下。这是因为监视器锁（monitor）是依赖于底层的操作系统的
Java并发——synchronized关键字
雪月清的博客
12-20 606
详解Java中的关键字synchronized的作用范围、底层实现、锁升级的过程、优缺点
Java 基础 —— synchronized 关键字详解
IT__learning的博客
11-03 1988
一、synchronized 三大特性 在多线程的环境下，多个线程同时访问共享资源会出现一些问题，而 synchronized 关键字则是用来保证线程同步的。 synchronized 关键字可以保证并发编程的三大特性：原子性、可见性、有序性。而 volatile关键字只能保证可见性和有序性，不能保证原子性，也称为是轻量级的 synchronized。 （1）原子性：一个或多个操作要么全部执行成功，要么全部执行失败。synchronized 关键字可以保证只有一个线程拿到锁，访问共享资源。 （2）可见性：
Java并发编程——深入理解Synchronized 关键字
dreamchaser533534的博客
09-16 320
1.synchronized 关键字 1.1.说一说自己对于 synchronized 关键字的了解 synchronized关键字解决的是多个线程之间访问资源的同步性，synchronized关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。 另外，在 Java 早期版本中，synchronized属于重量级锁，效率低下。 为什么呢？ 因为监视器锁（monitor）是依赖于底层的操作系统的Mutex Lock来实现的，Java 的线程是映射到操作系统的原生线程之上...
Java关键字——synchronized
weixin_42547014的博客
07-21 3003
什么是synchronize 如何使用 底层原理 做过那些优化 对象在内存中 用户态？内核态？ 为什么效率低 一、认识 Synchronized synchornized 是 Java 中的一个关键字，解决的是多个线程之间访问资源的同步性，synchronized 关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。 另外，在 Java 早期版本中，synchronized 属于 重量级锁，效率低下。 重量级锁：其他线程试图获取锁时，都会被阻塞，只有持有锁的线程释放锁之后才会唤醒这些线.
Java并发编程——Synchronized关键字解析
想着百万年薪努力的小赵
08-31 237
  首先，让我们了解下这个关键字的作用，或者说是解决了什么问题   解决可见性、原子性、有序性问题   然后，再去看它是怎么使用的： 简单介绍： synchronized是Java中的关键字，是一种同步锁。 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
Java并发学习笔记（二）——Synchronized关键字与ReetrantLock同步锁
12-20
【Java并发学习笔记（二）——Synchronized关键字与ReentrantLock同步锁】 在Java多线程编程中，确保线程安全是非常重要的。Synchronized关键字和ReentrantLock是两种常见的同步机制，它们都用于保证线程的原子性、...
Java 多线程synchronized关键字详解(六)
09-03
Java中的`synchronized`关键字是多线程编程中的一个重要概念，用于控制并发访问共享资源，以避免数据不一致和竞态条件。在这个问题中，我们将深入理解`synchronized`的关键字用法，包括同步方法和同步块。 1. **...
java重量级锁回退轻量级_浅谈Java并发编程系列（七） —— 深入解析synchronized关键字...
weixin_35773130的博客
03-02 262
Synchronized关键字synchronized的锁机制的主要优势是Java语言内置的锁机制，因此，JVM可以自由的优化而不影响已存在的代码。任何对象都拥有对象头这一数据结构来支持锁，但是对于较大的对象系统开销会更大一些。java中的每一个对象都至少包含2个字(24 Bytes for 32bits & 28 Bytes for 64bits, 不包括已压缩的对象)。第一个字被称为M...
学习整理——以太帧、ip帧、udp/tcp帧、http报文结构
热门推荐
Jeffery_Gong的博客
04-28 3万+
从最简单的一个http请求开发，根据TCP/IP协议，分开来看每一层的数据帧结构，以及它们是怎样承担起网络服务得。 协议栈 因特网协议栈共有五层： 1.应用层，是网络应用程序及其应用层协议存留的地方。因特网的应用层包括许多协议，常见的有HTTP(它为web文档提供了请求和传送)、SMTP(它提供了电子邮件报文的传输)和FTP(它提供了两个端系统之间的文件传送)。 2.传输层，负责为信源和信
学习整理——html+css+js可拖动进度条
Jeffery_Gong的博客
06-22 1万+
问题 实现可拖动的进度条，类似于播放器那样。由于主要是应用在手机上，所以某些接口会因为浏览器内核的不同有所不同，没有做兼容性测试。Demo的平台为Android4.4，webview内核的话应该是chromium。 模型 在参考了网上一些代码后，决定实现模型如下（html）: html 用的嵌套布局。
学习整理——多进程和多线程概念理解
Jeffery_Gong的博客
05-06 7244
进程 一个进程，包括了代码、数据和分配给进程的资源（内存）。在计算机系统里直观地说一个进程就是一个PID，操作系统保护进程空间不受外部进程干扰，即一个进程不能访问到另一个进程的内存。有时候进程间需要进行通信，这时可以使用操作系统提供进程间通信机制。通常情况下，执行一个可执行文件操作系统会为其创建一个进程以供它运行。但如果该执行文件是基于多进程设计的话，操作系统会在最初的进程上创建出多个进程出来，
学习整理——C++ virtual虚函数与多态
Jeffery_Gong的博客
10-07 3547
多态与动态绑定 多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。引用Charlie Calverts对多态的描述——多态性是允许你将父对象设置成为一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。 另一个与多
学习整理——从安卓源码上看Activity
Jeffery_Gong的博客
04-27 2745
安卓开发的四大组件是Activity, service, broadcast receiver, 和content provider。作为业余的开发者，可能不需要太深入理解这些组件的内部实现，以及运行机制。但是如果想要在这方面有所进阶的话，这些实现的源码还是要啃的。本文将从官方源码上讲一下对activity的理解。 官方对Activity的开头描述为：
学习整理——Python中内置方法
Jeffery_Gong的博客
10-16 2621
内置方法 类似Java，Python中声明每一个类系统都会加上一些默认内置方法，提供给系统调用该类的对象时使用。比如需要实例化一个对象时，需要调用该类的__init__方法；使用print去打印一个类时，其实调用的是__str__方法；等等。 __init__(self, ...)：初始化对象，在创建新对象时调用。在方法里，可以初始化该对象的属性，否则调用其他时可能出“现has no attr
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值