synchronized关键字

最新推荐文章于 2022-07-13 17:47:05 发布
最新推荐文章于 2022-07-13 17:47:05 发布
阅读量268 收藏
点赞数
分类专栏： 难点解析 文章标签： synchronized关键字 并行 串行
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44802710/article/details/96884761
版权

文章目录

1. 基本概念:

在Java中当多线程访问一个方法或者代码块时,可能造成因为抢夺资源而造成进程死锁
使用synchronized关键字可以防止进程死锁

2. 主要用法

可以修饰在方法上

比如
 public void synchronized void method(){
 			//代码块
  }

可以修饰在对象上

  比如
   synchronized(某个对象){
   		//代码块
    }

可以修饰在类上

  比如
   synchronized(类名.class){
   //代码块
   }

3. 修饰在方法上

 public class SynchronizedTest1 {
	public synchronized void methodA(){
		try {
			for (int i = 0; i < 5; i++) {
				System.out.println("methodA()-"+i);
				Thread.sleep(1000);
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
	}
	public void methodB(){
		try {
			for (int i = 0; i < 5; i++) {
				System.out.println("methodB()-"+i);
				Thread.sleep(1000);
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		SynchronizedTest1 test = new SynchronizedTest1();
		
		Thread t1 = new Thread(new Runnable(){
			@Override
			public void run() {
				test.methodA();				
			}
		});
		t1.start();
		
		Thread t2 = new Thread(new Runnable(){
			@Override
			public void run() {
				test.methodB();
			}
		});
		t2.start();
	}
}

结果显示:作用在同一个实例对象一个线程调用synchronized方法修饰的方法,另一个线程调用没有被
synchronized修饰的方法,是异步的,并行执行
在这里插入图片描述

public class SynchronizedTest1_1 {
	public synchronized void methodA(){
		try {
			for (int i = 0; i < 5; i++) {
				System.out.println("methodA()-"+i);
				Thread.sleep(1000);
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
	}
	public synchronized void methodB(){
		try {
			for (int i = 0; i < 5; i++) {
				System.out.println("methodB()-"+i);
				Thread.sleep(1000);
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
	
	public static void main(String[] args) {
		SynchronizedTest1_1 test1 = new SynchronizedTest1_1();

		Thread t1 = new Thread(new Runnable(){
			@Override
			public void run() {
				test1.methodA();				
			}
		});
		t1.start();
		
		Thread t2 = new Thread(new Runnable(){
			@Override
			public void run() {
				test1.methodB();
			}
		});
		t2.start();
	}
}

结果显示:作用在同一个实例对象,两个线程都调用synchronized修饰的方法,是同步的,串行执行
在这里插入图片描述
总结:
　　1.当一类中的方法有被synchronized修饰时,一个线程被调用了被synchronized修饰的方法,那么其他线程就不能调用synchronized修饰的方法,原因:一个线程获得了对象的锁之后,其他线程就不能再获取这个对象的锁,只能等获取到锁的线程执行完后,才能够获取到对象的锁
　　2.当一类中的方法有被synchronized修饰时,一个线程被调用了被synchronized修饰的方法,但是其他线程可以调用没有被synchronized修饰的方法,原因:调用没有被synchronized修饰的方法,就不需要获取当前对象的锁,可以直接调用方法
　　3.如果实例化两个上面类的对象,那么test1和test2,即使同时调用methodA()方法,也是并行执行,是同步的,因为所调用的对象不是一个对象

4. 修饰在对象上

public class SynchronizedTest2 {
	public void methodA(){
		//同步代码块
		synchronized(this){
			try {
				for (int i = 0; i < 5; i++) {
					System.out.println("methodA()-"+i);
					Thread.sleep(1000);
				}
			} catch (Exception e) {
				// TODO: handle exception
				e.printStackTrace();
			}
		}
		
	}
	public void methodB(){
		try {
			for (int i = 0; i < 5; i++) {
				System.out.println("methodB()-"+i);
				Thread.sleep(1000);
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		SynchronizedTest2 test1 = new SynchronizedTest2();
		
		Thread t1 = new Thread(new Runnable(){
			@Override
			public void run() {
				test1.methodA();				
			}
		});
		t1.start();
		
		Thread t2 = new Thread(new Runnable(){
			@Override
			public void run() {
				test1.methodB();
			}
		});
		t2.start();
	}
}

结果显示:作用在同一个实例对象上,一个线程调用synchronized代码块,另一个线程可以调用非
synchronized代码块,是异步的,并行执行
在这里插入图片描述

public class SynchronizedTest2_1 {
	public void methodA(){
		//同步代码块
		synchronized(this){
			try {
				for (int i = 0; i < 5; i++) {
					System.out.println("methodA()-"+i);
					Thread.sleep(1000);
				}
			} catch (Exception e) {
				// TODO: handle exception
				e.printStackTrace();
			}
		}
	}
	public void methodB(){
		synchronized(this){
			try {
				for (int i = 0; i < 5; i++) {
					System.out.println("methodB()-"+i);
					Thread.sleep(1000);
				}
			} catch (Exception e) {
				// TODO: handle exception
				e.printStackTrace();
			}
		}
	}
	
	public static void main(String[] args) {
		SynchronizedTest2_1 test1 = new SynchronizedTest2_1();
		
		Thread t1 = new Thread(new Runnable(){
			@Override
			public void run() {
				test1.methodA();				
			}
		});
		t1.start();
		
		Thread t2 = new Thread(new Runnable(){
			@Override
			public void run() {
				test1.methodB();
			}
		});
		t2.start();
	}
}

结果显示:作用在同一个实例对象,两个线程都调用synchronized修饰的代码块,是同步的,串行执行
在这里插入图片描述
总结:
　　修饰在代码块上的synchronized可以使代码实用性更强,达到只同步方法中的部分代码,而不是同步所有的代码

5. 同时修饰在方法和对象上

public class SynchronizedTest3 {
	//给方法加同步
	public synchronized void methodA(){
		try {
			for (int i = 0; i < 5; i++) {
				System.out.println("methodA()-"+i);
				Thread.sleep(1000);
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		
	}
	//给代码块加同步
	public void methodB(){
		synchronized(this){
			try {
				for (int i = 0; i < 5; i++) {
					System.out.println("methodB()-"+i);
					Thread.sleep(1000);
				}
			} catch (Exception e) {
				// TODO: handle exception
				e.printStackTrace();
			}
		}
	}
	
	public static void main(String[] args) {
		SynchronizedTest3 test1 = new SynchronizedTest3();
		
		Thread t1 = new Thread(new Runnable(){
			@Override
			public void run() {
				test1.methodA();				
			}
		});
		t1.start();
		
		Thread t2 = new Thread(new Runnable(){
			@Override
			public void run() {
				test1.methodB();
			}
		});
		t2.start();
	}
}

结果显示:作用在同一个实例对象上,synchronized和synchronized(this)二者没有区别,都作用在this对象上, 给this对象添加锁,所以会同步,串行执行
在这里插入图片描述
总结:
　　1.synchronized和synchronized(this)二者没有区别,都作用在this对象上,当都需要调用对象的锁的时候,就要等待前者执行完后,才能获取对象的锁
　　2. 如果把methodB()方法中的this换成别的对象,那么调用此方法所需要的对象的锁就不是当前test1对象的锁,而是该方法所修饰对象的锁,那么线程t1和t2就是同步的,并行执行

6. 修饰在类上:

public class SynchronizedTest4 {
	public synchronized static void methodA(){
		try {
			for (int i = 0; i < 5; i++) {
				System.out.println("methodA()-"+i);
				Thread.sleep(1000);
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		
	}
	public void methodB(){
		synchronized(SynchronizedTest4.class){
			try {
				for (int i = 0; i < 5; i++) {
					System.out.println("methodB()-"+i);
					Thread.sleep(1000);
				}
			} catch (Exception e) {
				// TODO: handle exception
				e.printStackTrace();
			}
		}
	}
	
	public static void main(String[] args) {
		SynchronizedTest4 test1 = new SynchronizedTest4();
		
		
		Thread t1 = new Thread(new Runnable(){
			@Override
			public void run() {
				test1.methodA();				
			}
		});
		t1.start();
		
		Thread t2 = new Thread(new Runnable(){
			@Override
			public void run() {
				test1.methodB();
			}
		});
		t2.start();
	}
}

结果显示:修饰在类上所以是同一对象的锁,所以是同步的串行执行
在这里插入图片描述
总结:
　　1.static synchronized 和 synchronized(类名.class)都是作用在同一个类锁上,所以会同步
　　2.如果把synchronized(类名.class)中的类名换成Object(指的是与static synchronized修饰的不同的类),那么t1和t2就是异步的可以并行执行

7. 总结:

1.方法上只有synchronized关键字锁的是对象,方法上有static synchronized两个关键字修饰锁的是类
2.在分析synchronized关键字时要注意不是修饰的方法锁的就是方法,可能时对象或者类
3.有多个synchronized关键字的方法,执行时需要等待对象的锁,先占有锁的线程先执行,其他线程要等待对象的锁,拿到锁之后才能执行
4.注意不带synchronized关键字的方法,线程调用的时候不需要等待对象的锁可以直接执行

  • 个人感悟:

通过今天的学习多少对synchronized关键字有了一点自己的了解,一面的一些结论是自己撰写的,可能措辞有些不恰当,大家可以提出来,我会尽快改正,另外,如果大家觉得我写的有问题,也可以和我来探讨,走向java大佬的路还很,漫长呀!!

小张小张,自有主张
关注
专栏目录
synchronized 关键字详解
TanaStudy的博客
04-07 7090
synchronized 关键字1. synchronized 关键字的三种使用方法1.1. 修饰实例方法2.2. 修饰静态方法3.3. 修饰代码块2. 双重检验锁方式实现单例模式3. 构造方法可以使用 synchronized 关键字修饰么？4. JDK1.6 之后的 synchronized 关键字底层做了哪些优化？5. synchronized 和 ReentrantLock 的区别6. synchronized 关键字与Lock的区别 synchronized 关键字解决的是多个线程之间访问资源的同
synchronized修饰代码块用类名作为锁实现线程同步(锁功能/线程安全)
qq_43079667的博客
06-04 199
知识点：http://note.youdao.com/noteshare?id=5d44cd6e03ba201670ea36c2e106e719&sub=F3BA3E6EB60B4D64BA0A846F4C7DCCA6 案例1：用非本类的类作为锁—Object public class DemowenApplication extends Thread { static Mm bb = new Mm(); // Mm bb = new Mm(); public void run() {
编写高质量代码:改善Java程序的151个建议(第3章:类、对象及方法___建议31~51)
chetianyao8457的博客
07-12 197
书读的多而不思考，你会觉得自己知道的很多。 书读的多而思考，你会觉得自己不懂的越来越多。 -----江疏影 在面向对象编程(Object-Oriented Programming, OOP)的世界里，类和对象是真实世界的描述工具，方法是行为和动作的展示形式，封装、继承、多态则是其多姿多彩...
Java 多线程(五）之 synchronized 的使用
09-01 320
目录 1 线程安全 2 互斥锁 3 内置锁 synchronized 3.1 普通同步方法，锁是当前实例对象(this) 3.1.1 验证普通方法中的锁的对象是同一个。 3.1.2 验证不同的对象普通方法的锁不一样 3.2...
【多线程锁】synchronized对象锁与类锁用法
Dust_heart的博客
07-13 4124
本文主要介绍synchronized对象锁与类锁用法，入门级别使用
举例讲解Java中synchronized关键字的用法
09-02
在Java编程语言中，`synchronized`关键字是一个非常重要的概念，它主要用于多线程环境中的线程同步，确保共享资源的正确访问，防止数据不一致性。以下是对`synchronized`关键字使用方法的详细讲解： 1. **修饰实例...
Java synchronized关键字使用方式及特性解析
08-25
需要注意的是，synchronized关键字的使用需要遵守一定的原则，例如避免使用synchronized关键字在循环语句中，以免出现死锁等问题。此外，synchronized关键字也可以与其他线程同步工具结合使用，以实现更复杂的线程...
Lock接口与synchronized关键字
最新发布
04-19
### Lock接口与synchronized关键字详解 #### 一、概述 在Java并发编程中，Lock接口与synchronized关键字都是实现同步的重要工具。它们虽然都用于控制多线程对共享资源的访问，但在使用方式、功能特性及灵活性方面...
synchronized的用法
make2019_y的博客
03-05 400
多个线程去共享资源、一段代码可能会出现一些不能预料的问题。就比如模拟三个窗口同时售票 package com.smallchili.demo; public class CreateThread { public static void main(String[] args) { ThreadDemo2 t = new ThreadDemo2(); Thread t1 = ...
Synchronized对象锁和类锁
Jiang216的博客
05-13 916
Java中的synchronized关键字，用于修饰需要同步的方法或需要同步的代码块，默认以当前对象作为锁的对象。 在学习synchronized关键字时，有以下几点注意事项： 一把锁只能同时被一个线程获取，没有获得锁的线程只能等待； 每个实例都对应有自己的一把锁(this),不同实例之间互不影响；例外：锁对象是*.class以及synchronized修饰的是static方法的时候，所有对象公用同一把锁； synchronized修饰的方法，无论方法正常执行完毕还是抛出异常，都会释放锁。 这里我们
synchronized（class） 与 synchronized（this）区别
haha_321的专栏
11-23 9154
先上代码 public class SynchronizedTest { /** * 锁住class对象 */ public void synchronizedClass() { synchronized (SynchronizedTest.class) { System.out.println("synchronizedClass"); try { Thr
Synchronized的用法
菜鸟教程
01-29 1894
Java中Synchronized的用法（简单介绍） </h1> <div class="clear"></div> <div class="postBody"> 简单介绍 synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：  　　1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；&
《多线程编程》学习之五：synchronized同步语句块，静态同步synchronized方法与synchronized(类名.class)代码块
studyhxz的博客
10-20 3051
在介绍同步语句块之前，先做一个实验，验证多个线程调用同一个同步方法是随机的。 例子一： 1）MyList.java 2）测试：         可见，在同步方法中的代码是同步打印的，但线程A和线程B是异步执行的，这可能会出现脏读的情况。看下面的例子： 例子二： 1） 在上面例子的基础上，创建业务类MyListService.java:
使用for循环用*打印菱形
weixin_44802710的博客
07-11 4708
技巧: 首先找找到规律,先画上面的三角形: 一共有四行 第一行的前面有三个空格,一个* 第二行的前面是两个空格,三个 * 第三行的前面是一个空格,五个* 第四行的前面是零个空格,七个* 所以得出结论空格数是总行数-行数,*的个数是2倍的行数-1 Scanner input = new Scanner(System.in);//从键盘录入 System.out.println("请输...
Collections.sort()方法给集合排序
weixin_44802710的博客
07-16 2282
Collections.sort()方法给集合排序 前言 因为Collections里面的sort()方法是静态方法,所以可以直接类名打点调用sort方法 Collections.sort()有两种参数形式 第一种形式 //第一种形式Connections.sort(List<T> list) /*情况一:传入数据内容只有一种数据类型且该类型数据已实现了Comparable...
Cannot convert value of type 'java.lang.String' to required type ''javax.sql.DataSource'
weixin_44802710的博客
09-11 1459
org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name ‘userController’: Unsatisfied dependency expressed through field ‘userService’; nested exception is org....
builder模式创建对象
weixin_44802710的博客
07-11 807
在现实的开发中类中的属性可能只有一个,多的可能会十几个,而这些属性有的一些是必填项有的是非必填项,那么怎么写才能够使数据存储更佳安全的同时又保证代码的整洁 builder模式就是个不错的选择 //首先这里创建一个普通的类,类名就是Person,里面有四个属性(姓名,年龄,性别和身份证号) //其中姓名和身份证号是必填项,年龄和性别可以选填 public class Person { privat...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值