java多线程 synchronized

最新推荐文章于 2021-12-07 21:57:52 发布
最新推荐文章于 2021-12-07 21:57:52 发布
阅读量312 收藏
点赞数
分类专栏： java学习 文章标签： 多线程 并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010585448/article/details/49892061
版权

在java多线程并发操作中，如果不加任何的同步控制，有可能会出现一些错误的情况。

package com.lql.thread;


public class MyTask10 implements Runnable {

	private int n = 10;


	public MyTask10() {
	}
	
	public void method(){
		while (n > 0) {
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "-->"
					+ n--);
		}
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		method();
	}

	public static void main(String[] args) {
		MyTask10 task10 = new MyTask10();
		for (int i = 0; i < 5; i++) {
			Thread thread = new Thread(task10);
			thread.start();
		}
	}
}
一次运行结果:

Thread-1-->10
Thread-2-->9
Thread-0-->8
Thread-3-->9
Thread-4-->7
Thread-0-->6
Thread-2-->4
Thread-1-->5
Thread-3-->6
Thread-4-->3
Thread-3-->1
Thread-2-->-1
Thread-0-->2
Thread-1-->0
Thread-4-->-2

可以看到一些数字打印了两遍，一些打印了一遍，更为要命的是还打印出来一些负数。如果学习过操作系统并发的知识的话，这个问题其实不难理解。JVM为每个线程分配时间片，并选择了一个线程将处理机分配给他。但是这个线程执行执行到sleep()时进入了休眠状态（也就是阻塞态），这时JVM就会再选择一个线程分配处理机资源。设想如果当n=1时，有三个线程都进入了都执行到Thread.sleep(10)，当这三个线程被唤醒使就会去执行打印语句部分。因为他们都已经经历了n>0条件，所以都会执行打印语句，而且执行n--，就可能出现上述出现-1，-2的情况。打印两次也是这样，当一个线程执行完打印n，还没来得及对n进行减一，就被剥夺了处理机。另一个线程此时又打印了一次n。这样的情况在并发编程中是不允许的，就比如买火车票，上述情况就如同有的票被卖给两个人，没有票了还在售卖。

java中提供了同步关键字:synchrnoized（同步）来解决多线程并发操作中的由于共享资源导致的资源冲突。

package com.lql.thread;


public class MyTask10 implements Runnable {

	private int n = 10;


	public MyTask10() {
	}
	
	public synchronized void method(){
		while (n > 0) {
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "-->"
					+ n--);
		}
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		method();
	}

	public static void main(String[] args) {
		MyTask10 task10 = new MyTask10();
		for (int i = 0; i < 5; i++) {
			Thread thread = new Thread(task10);
			thread.start();
		}
	}
}
运行结果：

Thread-0-->10
Thread-0-->9
Thread-0-->8
Thread-0-->7
Thread-0-->6
Thread-0-->5
Thread-0-->4
Thread-0-->3
Thread-0-->2
Thread-0-->1
在方法前加一个synchronized关键字，该方法就变成了一个同步方法，就不会出现上一个那样错误的情况了。但是又有一个奇怪的情况:在主线程中我开启了五个线程去执行task10这个任务，为什么只有打印出来的线程名只有一个Thread-0呢。这里就得说明一下synchronized同步的机制了。在java中每个对象都有一个对象锁，一个对象的对象锁同一时间只能由一个线程获取。一个线程从获取该对象锁的时刻起到该线程释放该对象锁止，其他线程是无法取得该对象锁的。如果线程无法获取该对象的对象锁，那么这些线程是无法去执行该对象的同步方法的。例子的运行结果就是因为：Thread-0取得了task10这个对象的对象锁，他就一直占用着task10对象的对象锁。另外四个线程只能干巴巴的看着，进不了被同步的方法里去。

我在同步方法之前和之后又加了两个普通的输出语句，来说明对象锁对于同步代码块的锁定。

package com.lql.thread;


public class MyTask10 implements Runnable {

	private int n = 10;


	public MyTask10() {
	}
	
	public synchronized void method(){
		while (n > 0) {
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "-->"
					+ n--);
		}
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println(Thread.currentThread().getName() + "hello");
		
		method();
		
		System.out.println(Thread.currentThread().getName()+"hello");
	}

	public static void main(String[] args) {
		MyTask10 task10 = new MyTask10();
		for (int i = 0; i < 5; i++) {
			Thread thread = new Thread(task10);
			thread.start();
		}
	}
}
运行结果：

Thread-1hello
Thread-3hello
Thread-0hello
Thread-4hello
Thread-2hello
Thread-1-->10
Thread-1-->9
Thread-1-->8
Thread-1-->7
Thread-1-->6
Thread-1-->5
Thread-1-->4
Thread-1-->3
Thread-1-->2
Thread-1-->1
Thread-1hello
Thread-2hello
Thread-4hello
Thread-0hello
Thread-3hello

可以看到确实开启了五个线程,而且同步方法里的代码只有一个线程在执行（而且这次是Thread-1占用了对象锁），执行完同步方法里的代码后，其他线程这时又登场了。


我们再来看一种情况。

package com.lql.thread;


public class MyTask10 implements Runnable {

	private int n = 10;


	public MyTask10() {
	}
	
	public synchronized void method(){
		while (n > 0) {
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "-->"
					+ n--);
		}
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		
		method();
		
	}

	public static void main(String[] args) {
		for (int i = 0; i < 5; i++) {
			Thread thread = new Thread(new MyTask10());
			thread.start();
		}
	}
}


与上边的情况的不同之处在于我为每个线程都分配了一个任务，每个线程锁执行的是不同的MyTask10类的对象。 
Thread-0-->10
Thread-3-->10
Thread-2-->10
Thread-1-->10
Thread-4-->10
Thread-1-->9
Thread-2-->9
Thread-3-->9
Thread-0-->9
Thread-4-->9
Thread-3-->8
Thread-2-->8
Thread-1-->8
Thread-0-->8
Thread-4-->8
Thread-1-->7
Thread-0-->7
Thread-3-->7
Thread-2-->7
Thread-4-->7
Thread-1-->6
Thread-2-->6
Thread-0-->6
Thread-3-->6
Thread-4-->6
Thread-1-->5
Thread-3-->5
Thread-0-->5
Thread-2-->5
Thread-4-->5
Thread-1-->4
Thread-0-->4
Thread-2-->4
Thread-3-->4
Thread-4-->4
Thread-1-->3
Thread-2-->3
Thread-0-->3
Thread-3-->3
Thread-4-->3
Thread-1-->2
Thread-0-->2
Thread-2-->2
Thread-3-->2
Thread-4-->2
Thread-1-->1
Thread-0-->1
Thread-2-->1
Thread-3-->1
Thread-4-->1
这种情况其实更好理解，因为五个线程所执行的是不同的任务，所以就不存在共享资源的问题。因为这五个线程每次所执行的是五个不同的MyTask10对象的method方法，每线程各自完成各自的任务，互不影响， 如果从对象锁的角度来说是因为五个对象都有各自的对象锁，一个线程占用一个对象的对象锁也不会影响另外一个线程去使用另一个对象的对象锁。即便没有synchrnoized来实现同步也不会出现一些错误的结果（就是打印出0，-1，-2的情况），没有资源共享时也没有必要同步。


同步静态方法:

这里我将method方法改为了static方法，static方法又称类方法，static修饰的方法或者变量在内存中只有一个副本，不管创建多少个类的实例，都只有一个副本。

package com.lql.thread;


public class MyTask10 implements Runnable {

	private static int n = 10;


	public MyTask10() {
	}
	
	public static synchronized void method(){
		while (n > 0) {
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "-->"
					+ n--);
		}
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		
		method();
		
	}

	public static void main(String[] args) {
		for (int i = 0; i < 5; i++) {
			Thread thread = new Thread(new MyTask10());
			thread.start();
		}
	}
}

运行结果:

Thread-0-->10
Thread-0-->9
Thread-0-->8
Thread-0-->7
Thread-0-->6
Thread-0-->5
Thread-0-->4
Thread-0-->3
Thread-0-->2
Thread-0-->1

同步静态方法又出现了不一样的情况，我在主线程中明明是用开了五个线程，而且五个线程分别取执行五个不同的任务。为什么又是只有Thread-0线程执行呢?   原因是同步的方法是静态方法（类方法），如果同步的是类方法，线程获取的对象锁就会是累的对象，MyTask10.class这个对象，我们知道一个类只有一个类对象。Thread-0占用了类对象的对象锁，其他线程也就无法进入同步方法区了。总结起来就是同步静态方法，线程的拥有的对象锁是类对象的对象锁，无论定义多少个该类的对象，都不能进入同步区。


上边说的都是同步方法，java还提供了另外一种细粒度的实现线程同步的机制——同步代码块。

package com.lql.thread;


public class MyTask11 implements Runnable {

	private int n = 10;
	
	private String name = "";
	
	public MyTask11(){
		
	}
	
	public void method(){
		
		System.out.println(Thread.currentThread().getName() +"hello");
		
		synchronized (this) {
			while(n > 0){
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName() +"-->" + n--);
			}
		}
	}
	
	@Override
	public void run() {
	// TODO Auto-generated method stub
		method();
	}
	
	

	public static void main(String[] args) {
		MyTask11 task11 = new MyTask11();
		Thread thread = new Thread(task11);
		Thread thread2 = new Thread(task11);
		thread.start();
		thread2.start();
	}
}
Thread-0hello
Thread-1hello
Thread-0-->10
Thread-0-->9
Thread-0-->8
Thread-0-->7
Thread-0-->6
Thread-0-->5
Thread-0-->4
Thread-0-->3
Thread-0-->2
Thread-0-->1

同步方法所能实现的同步，同步代码块也都能实现。同步方法有时同步的范围太大，有时只是一小部分的代码是临界区，如果将整个方法都整成同步方法并不好，这与并发的理念是相悖的。所以就有了同步代码块。

synchrnized(this)括号中的对象指定当前线程获取哪个对象的对象锁，因为对象的锁是唯一的，所以一个线程获取了对象锁，在该线程释放锁之前，其他线程也就无法再取得该对象锁，在一个线程执行完同步块代码后，才释放该对象锁。synchrnized（）括号里可以使任何一个对象，因为一个确定的对象他的对象锁是唯一的。只要一个线程取得了对象锁，其他线程都无法进入同步块。


总结以上所有内容:

1.当并发编程共享资源时，要使用同步来确保同一时刻只有一个线程进入临界区。

2.java中每个对象都有一个对象锁，synchronized就是基于对象锁来实现同步，一个线程占用了对象锁其他线程就必须等待上一个线程释放了对象锁才能进入被同步的临界区。

3.同步静态方法时，线程获取的对象锁是类对象（MyTask.class）的对象锁。无论定义多少个对象，被同步的静态方法都无动于衷。哪个线程有了类对象的对象，就让哪个线程进到同步区。

4.同步块是一种细粒度实现同步的方法，同步块指定执行到同步块的线程获取哪个对象的对象锁。由于一个确定对象的对象锁唯一，所以能够实现只有一个线程进入同步区代码执行。


以上是个人的理解，如有错误或不当欢迎批评指正。



2513LQL
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 多线程synchronized关键字详解(六)
09-03
主要介绍了Java 多线程synchronized关键字详解(六)的相关资料,需要的朋友可以参考下
Java多线程之synchronized
qq_35716085的博客
07-20 6116
synchronized具有同步功能，是一种互斥锁，锁的是对象。如果既想保证共享变量的可见性和有序性，又想保证原子性，那么synchronized关键字是一个不错的选择。synchronized的缺点：1.synchronized底层是由jvm实现，因此不能手动控制锁的释放，不如lock锁灵活，synchronized修饰的方法一旦出现异常，jvm保证锁会被释放（lock锁需要在finally中释放）。2.synchronized是非公平锁，不保证公平性。
JAVA多线程synchronized关键字不起作用
LMR的博客
05-23 1万+
今天在使用synchronized关键字来实现共享变量线程安全时，结果不起作用（自己犯了小错误。。。）。这实在有点颠覆我的三观，先贴上代码： public class VolatileTest {//volatile关键字不能保证遍历的线程安全性 // Object o = new Object();//线程不安全？？ public volatile int counts ...
Java多线程之Synchronized深入理解
上善若泪
12-07 1737
文章目录1 Synchronized1.1 引言1.2 概念理解1.2.1 不同锁对象1.2.2 对象锁和类锁概念区别1.2.3 同步概念1.2.4 Synchronized概念1.3 原理1.3.1 Synchronized实现原理1.3.2 Java对象头1.4 实际操作1.4.1 对象锁1.4.1.1 使用同一对象锁1.4.1.2 使用不同对象锁1.4.4.3 Synchronized块1.4.2 类锁 1 Synchronized 1.1 引言 在多线程并发编程中Synchronized一直是元老级
Java多线程之Synchronized和Lock的区别
努力努力再努力L
05-28 645
Java多线程之Synchronized和Lock的区别 目录： 原始构成 使用方法 等待是否可以中断 加锁是否公平 锁绑定多个条件Condition 小结：Lock相比较Synchronized的优点 1. 原始构成 synchronized是关键字属于JVM层面， 进入：monitorenter（底层是通过monitor对象来完成，其实wait/notify等方法也依赖于monit...
Java多线程超详解
热门推荐
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
Java多线程synchronized关键字详解(六)共5
10-30
Java多线程synchronized关键字详解(六)共5页.pdf.zip
Java多线程synchronized同步方法详解
08-24
主要介绍了Java多线程synchronized同步方法详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java 多线程synchronized互斥锁demo
12-16
一个多线程访问的同一个资源，java synchronized互斥锁的用法，android和此用法一致。
java多线程编程之Synchronized块同步方法
09-03
主要介绍了java多线程编程之Synchronized块同步方法，synchronized关键字又称同步锁，当方法执行完后，会自动释放锁锁，只有一个线程能进入此方法，看看下文中各种例子对synchronized的详细解释
Rain Water Algorithm雨水优化算法附matlab代码.zip
04-26
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
基于springboot+vue的房屋租赁出售系统
04-26
提供的源码资源涵盖了安卓应用、小程序、Python应用和Java应用等多个领域，每个领域都包含了丰富的实例和项目。这些源码都是基于各自平台的最新技术和标准编写，确保了在对应环境下能够无缝运行。同时，源码中配备了详细的注释和文档，帮助用户快速理解代码结构和实现逻辑。 适用人群： 这些源码资源特别适合大学生群体。无论你是计算机相关专业的学生，还是对其他领域编程感兴趣的学生，这些资源都能为你提供宝贵的学习和实践机会。通过学习和运行这些源码，你可以掌握各平台开发的基础知识，提升编程能力和项目实战经验。 使用场景及目标： 在学习阶段，你可以利用这些源码资源进行课程实践、课外项目或毕业设计。通过分析和运行源码，你将深入了解各平台开发的技术细节和最佳实践，逐步培养起自己的项目开发和问题解决能力。此外，在求职或创业过程中，具备跨平台开发能力的大学生将更具竞争力。 其他说明： 为了确保源码资源的可运行性和易用性，特别注意了以下几点：首先，每份源码都提供了详细的运行环境和依赖说明，确保用户能够轻松搭建起开发环境；其次，源码中的注释和文档都非常完善，方便用户快速上手和理解代码；最后，我会定期更新这些源码资源，以适应各平台技术的最新发展和市场需求。
杭电-[数据结构(c语言版)]复习题纲杭州电子科技大学.pdf
04-26
杭州电子科技大学，期末考试资料，计算机专业期末考试试卷，试卷及答案，数据结构。
年医院医生个人工作总结.docx
04-26
工作总结，新年计划，岗位总结，工作汇报，个人总结，述职报告，范文下载，新年总结，新建计划。
阿里巴巴笔试题目.docx
04-26
校园招聘笔试题目及答案
顺从宗族联动机器人matlab代码.zip
最新发布
04-26
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
基于Python的图像阴影检测与去除源码（高分期末大作业项目）.zip
04-26
基于Python的图像阴影检测与去除源码（高分期末大作业项目）.zip已获导师指导并通过的97分的高分期末大作业设计项目，可作为课程设计和期末大作业，下载即用无需修改，项目完整确保可以运行。 基于Python的图像阴影检测与去除源码（高分期末大作业项目）.zip已获导师指导并通过的97分的高分期末大作业设计项目，可作为课程设计和期末大作业，下载即用无需修改，项目完整确保可以运行。 基于Python的图像阴影检测与去除源码（高分期末大作业项目）.zip已获导师指导并通过的97分的高分期末大作业设计项目，可作为课程设计和期末大作业，下载即用无需修改，项目完整确保可以运行。 基于Python的图像阴影检测与去除源码（高分期末大作业项目）.zip已获导师指导并通过的97分的高分期末大作业设计项目，可作为课程设计和期末大作业，下载即用无需修改，项目完整确保可以运行。 基于Python的图像阴影检测与去除源码（高分期末大作业项目）.zip已获导师指导并通过的97分的高分期末大作业设计项目，可作为课程设计和期末大作业，下载即用无需修改，项目完整确保可以运行。基于Python的图像阴影检
Android阅读器源码
04-26
Android阅读器源码是用于在Android平台上开发电子书阅读器应用的源代码。阅读器可以支持多种电子书格式，如EPUB、PDF、TXT等，并提供诸如翻页、搜索、书签、夜间模式等功能。
该项目包含为与用户合作的微电网能源管理系统的多目标优化而开发的matlab代码.zip
04-26
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
java多线程锁synchronized
03-16
Java中的synchronized关键字可以用于实现多线程锁，保证多个线程对共享资源的访问是互斥的。当一个线程获取了锁，其他线程就必须等待该线程释放锁后才能继续访问共享资源。synchronized可以用于方法和代码块，使用方法非常简单，只需要在需要同步的方法或代码块前加上synchronized关键字即可。使用synchronized可以有效避免多线程并发访问共享资源时出现的数据竞争和不一致问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值