「java」synchronized（this） 区块

最新推荐文章于 2023-10-19 09:48:39 发布
最新推荐文章于 2023-10-19 09:48:39 发布
阅读量877 收藏 1
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36098284/article/details/105546461
版权

 

该关键字的作用：当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。

synchronized关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。

用法是: synchronized(this){/*区块*/}，它的作用域是当前对象； 

 

下面使用例子分别解释下面几句话的含义：

  一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

     二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

     三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

     四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

     五、以上规则对其它对象锁同样适用.

 

1.当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

3.尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。  

4.第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。


public class pra implements Runnable{

	public void run()
	{
		synchronized(this){
			for(int i = 0 ; i<5;i++)
			{
				System.out.println(Thread.currentThread().getName() + " synchronized loop" + i);
			}
		}
	}

	public static void main(String[] args) {
		pra t1 = new pra();
		Thread ta = new Thread(t1,"A");
		Thread tb = new Thread(t1,"B");
		ta.start();
		tb.start();
	}

}

输出结果：

可以发现，线程A在执行完成后，才开始执行线程B。（为什么是先执行A，后执行B呢，就是因为ta.start（）在前面，如果ta.start在后面，那么就会先执行线程B，因此看准谁先start也很重要）

如果没有“synchronized”的修饰，那么该方法在执行的时候，AB线程会交错的形式进行。

A synchronized loop0
A synchronized loop1
A synchronized loop2
A synchronized loop3
A synchronized loop4
B synchronized loop0
B synchronized loop1
B synchronized loop2
B synchronized loop3
B synchronized loop4

 

2. 然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

 2.1 一个调用m4t1,（）一个调用m4t2（）


public class pra{

	public void m4t1()
	{
		synchronized(this)
		{
			int i = 5;
			while(i -- >0)
			{
				System.out.println(Thread.currentThread().getName()+ " : "+ i);
				try
				{
					Thread.sleep(500);
				}catch(InterruptedException ie){
					
				}
			} 
		}
	}
	
	public void m4t2()
	{
		int i = 5;
		while(i -- >0)
		{
			System.out.println(Thread.currentThread().getName()+ " : "+ i);
			try
			{
				Thread.sleep(500);
			}catch(InterruptedException ie){
				
			}
		} 
	}

	public static void main(String[] args) {
		final pra myt2 = new pra();
		Thread t1 = new Thread(new Runnable(){public void run() { myt2.m4t1();}},"t1");
		Thread t2 = new Thread(new Runnable(){public void run() { myt2.m4t2();}},"t2");
		 t1.start();  
         t2.start();  
	}

}

输出结果：因为1.2两个线程，互补影响，那么谁先被cpu调度就先执行谁。每次运行的结果应该也是不同的

t1 : 4
t2 : 4
t1 : 3
t2 : 3
t1 : 2
t2 : 2
t2 : 1
t1 : 1
t2 : 0
t1 : 0

而且：有人可能有疑问：为什么是（4433221100），是不是两个线程必须这么交错执行。

经过测试，并非如此，如果把m4t1（）的输出，改成50，就可以发现，并一定是（49 4 48 3 47 2 ...）这样的

 

2.2 如果都调用m4t2（）函数


public class pra{

	public void m4t1()
	{
		synchronized(this)
		{
			int i = 5;
			while(i -- >0)
			{
				System.out.println(Thread.currentThread().getName()+ " : "+ i);
				try
				{
					Thread.sleep(500);
				}catch(InterruptedException ie){
					
				}
			} 
		}
	}
	
	public void m4t2()
	{
		int i = 5;
		while(i -- >0)
		{
			System.out.println(Thread.currentThread().getName()+ " : "+ i);
			try
			{
				Thread.sleep(500);
			}catch(InterruptedException ie){
				
			}
		} 
	}

	public static void main(String[] args) {
		final pra myt2 = new pra();
		Thread t1 = new Thread(new Runnable(){public void run() { myt2.m4t2();}},"t1");
		Thread t2 = new Thread(new Runnable(){public void run() { myt2.m4t2();}},"t2");
		 t1.start();  
         t2.start();  
	}

}

输出结果：

注意，如果都是执行m4t2函数，该函数是没有synchronized修饰的，因此线程是看cpu调度来执行。

t2 : 4
t1 : 4
t1 : 3
t2 : 3
t1 : 2
t2 : 2
t1 : 1
t2 : 1
t2 : 0
t1 : 0

 

2.3 三个线程


public class pra{

	public void m4t1()
	{
		synchronized(this)
		{
			int i = 5;
			while(i -- >0)
			{
				System.out.println(Thread.currentThread().getName()+ " : "+ i);
				try
				{
					Thread.sleep(500);
				}catch(InterruptedException ie){
					
				}
			} 
		}
	}
	
	public void m4t2()
	{
		int i = 5;
		while(i -- >0)
		{
			System.out.println(Thread.currentThread().getName()+ " : "+ i);
			try
			{
				Thread.sleep(500);
			}catch(InterruptedException ie){
				
			}
		} 
	}

	public static void main(String[] args) {
		final pra myt2 = new pra();
		Thread t1 = new Thread(new Runnable(){public void run() { myt2.m4t1();}},"t1");
		Thread t2 = new Thread(new Runnable(){public void run() { myt2.m4t2();}},"t2");
		Thread t3 = new Thread(new Runnable(){public void run() { myt2.m4t1();}},"t3");
		t3.start(); 
		t1.start();  
		t2.start();  
         
	}

}

输出结果：

因为3.1都执行有“synchronized”修饰的m4t1（），而且是t3先start，因此t1会等到t3 全部执行完，才开始执行。

t3 : 4
t2 : 4
t3 : 3
t2 : 3
t2 : 2
t3 : 2
t3 : 1
t2 : 1
t3 : 0
t2 : 0
t1 : 4
t1 : 3
t1 : 2
t1 : 1
t1 : 0


 

public class Thread3 { 
     class Inner { 
          private void m4t1() { 
               int i = 5; 
               while(i-- > 0) { 
                    System.out.println(Thread.currentThread().getName() + " : Inner.m4t1()=" + i); 
                    try { 
                         Thread.sleep(500); 
                    } catch(InterruptedException ie) { 
                    } 
               } 
          } 
          private void m4t2() { 
               int i = 5; 
               while(i-- > 0) { 
                    System.out.println(Thread.currentThread().getName() + " : Inner.m4t2()=" + i); 
                    try { 
                         Thread.sleep(500); 
                    } catch(InterruptedException ie) { 
                    } 
               } 
          } 
     } 
     private void m4t1(Inner inner) { 
          synchronized(inner) { //使用对象锁 
          inner.m4t1(); 
     } 
     private void m4t2(Inner inner) { 
          inner.m4t2(); 
     } 
     public static void main(String[] args) { 
          final Thread3 myt3 = new Thread3(); 
          final Inner inner = myt3.new Inner(); 
          Thread t1 = new Thread( new Runnable() {public void run() { myt3.m4t1(inner);} }, "t1"); 
     Thread t2 = new Thread( new Runnable() {public void run() { myt3.m4t2(inner);} }, "t2"); 
     t1.start(); 
     t2.start(); 
  } 
}

输出结果：

尽管线程t1获得了对Inner的对象锁，但由于线程t2访问的是同一个Inner中的非同步部分。所以两个线程互不干扰。

     t1 : Inner.m4t1()=4  
     t2 : Inner.m4t2()=4  
     t1 : Inner.m4t1()=3  
     t2 : Inner.m4t2()=3  
     t1 : Inner.m4t1()=2  
     t2 : Inner.m4t2()=2  
     t1 : Inner.m4t1()=1  
     t2 : Inner.m4t2()=1  
     t1 : Inner.m4t1()=0  
     t2 : Inner.m4t2()=0

现在在Inner.m4t2()前面加上synchronized：

     private synchronized void m4t2() {  
          int i = 5;  
          while(i-- > 0) {  
               System.out.println(Thread.currentThread().getName() + " : Inner.m4t2()=" + i);  
               try {  
                    Thread.sleep(500);  
               } catch(InterruptedException ie) {  
               }  
          }  
     }

结果：

尽管线程t1与t2访问了同一个Inner对象中两个毫不相关的部分,但因为t1先获得了对Inner的对象锁，所以t2对Inner.m4t2()的访问也被阻塞，因为m4t2()是Inner中的一个同步方法。

     t1 : Inner.m4t1()=4  
     t1 : Inner.m4t1()=3  
     t1 : Inner.m4t1()=2  
     t1 : Inner.m4t1()=1  
     t1 : Inner.m4t1()=0  
     t2 : Inner.m4t2()=4  
     t2 : Inner.m4t2()=3  
     t2 : Inner.m4t2()=2  
     t2 : Inner.m4t2()=1  
     t2 : Inner.m4t2()=0

参考：https://blog.csdn.net/ahgaojie451/article/details/50900421

https://www.cnblogs.com/yjd_hycf_space/p/7526608.html

qq_1144521901
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java Synchronized的使用详解
08-18
Java Synchronized的使用详解 Java Synchronized是Java编程语言中的一种同步机制，用于解决并发编程中的线程安全问题。下面是对Java Synchronized的使用详解的知识点总结： 1. 为什么要使用Synchronized？ 在并发...
java synchronized关键字的用法
09-02
0; public synchronized void...综上所述，synchronized 关键字是 Java 中实现线程同步的重要手段，它通过加锁机制保证了线程安全。然而，在实际应用中，我们需要根据具体场景选择合适的同步策略，以兼顾性能和正确性。
Java中Synchronized的用法（简单介绍）
NeiHan2020的博客
03-04 6093
简单介绍 synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种： 　　1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； 　　2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 　　3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象； 　　4. 修改一个类，其作用的范围是synchronized后面括号括起来的...
java区块作用域_java synchronized详解
weixin_36250058的博客
02-27 336
1、synchronized关键字的作用域有二种：1)是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法(如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法)。这时，不同的对象实例的synchroni...
Java synchronized 详解
俊墨客
06-27 89
转载自：https://www.jianshu.com/p/ea9a482ece5f 由于同一进程的多个线程共享同一片存储空间，在带来方便的同时，也带来了访问冲突这个严重的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问。 需要明确的几个问题： synchronized关键字可以作为函数的修饰符，也可作...
Java synchronized 对象锁和类锁
好好学java
03-14 2089
一.对象锁和类锁的作用范围： 我们可以理解java中锁的概念。一个是实例锁（锁在某一个实例对象上，如果该类是单例，那么该锁也具有全局锁的概念），一个是全局锁（该锁针对的是类，无论实例多少个对象，那么线程都共享该锁）。实例锁对应的就是synchronized关键字，而类锁（全局锁）对应的就是static synchronized（或者是锁在该类的class或者classloader对象上）。 二、具体讲解synchronized作用域： 1）是某个对象实例内，synchron...
Java synchronized详解
huikaixikai1123的博客
05-25 457
Java synchronized详解 第一篇： 使用synchronized 在编写一个类时，如果该类中的代码可能运行于多线程环境下，那么就要考虑同步的问题。在Java中内置了语言级的同步原语－－synchronized，这也大大简化了Java中多线程同步的使用。我们首先编写一个非常简单的多线程的程序，是模拟银行中的多个线程同时对同一个储蓄账户进行存款、取款操作的。 在程序中我们
java synchronized
gyzhang
06-19 103
转载：http://www.cnblogs.com/tankaixiong/archive/2013/04/02/2995579.html第一篇：使用synchronized在编写一个类时，如果该类中的代码可能运行于多线程环境下，那么就要考虑同步的问题。在Java中内置了语言级的同步原语－－synchronized，这也大大简化了Java中多线程同步的使用。我们首先编写一个非常简单的多线程的程序，...
Java synchronized用法 | join用法
在路上的学习者
09-12 3627
synchronized：
Java 关键字：synchronized详解
最新发布
唯有努力，方可自信！
10-19 1万+
synchronized 是 Java 中用于实现线程同步的关键字，它提供了一种简单且有效的方式来控制多个线程对共享资源的访问。 synchronized 的作用是确保在同一时刻只有一个线程可以进入被 synchronized 修饰的代码块或方法，从而避免多个线程同时修改共享数据而引发的数据不一致性和并发访问问题。
java synchronized c_Java中synchronized关键字实现线程同步互斥
weixin_42136826的博客
02-24 117
Java多线程程序现在很常见，和数据库操作系统一样，多个线程会共享一个堆内存，如果不加以控制，不进行线程之间的同步，会造成数据混乱等。先看看下面这个程序：public class TestSynchronized implements Runnable {Timer timer = new Timer();public static void main(String args[]) {TestSy...
Java中synchronized正确使用方法解析
08-25
Java 中 synchronized 正确使用方法解析 Java 中 synchronized 关键字是解决线程安全问题的重要手段，它可以确保在多线程环境下，共享资源的访问安全性。本文将详细介绍 Java 中 synchronized 的正确使用方法，通过...
java synchronized demo
04-19
在Java编程语言中，`synchronized`关键字是一个非常重要的概念，它用于实现线程同步，以确保多线程环境下的数据一致性与安全性。本示例"java synchronized demo"旨在探讨`synchronized`关键字的用法及其作用机制。...
Java synchronized关键字使用方式及特性解析
08-25
synchronized (this){ for(int i=0; i;i++){ System.out.println(str+",执行中"); } } } 3. 作用在类上 synchronized关键字还可以作用在类上，从而锁定整个类。例如： public static void testClass(String ...
java（13）List-----List嵌套
热门推荐
qq_36098284的博客
04-14 2万+
我的需求是想一次性传递多个list。 现在在测试可以如何实现。查看test4：list<list<String>>的初始化 在我不同测试和思路中，对list传递有几个不同的猜测和实验。 test1：测试两个list的话，一个list存数据，那么另一个list是否可以存第一个list的首地址。 首先这个问题是可以实现的。 List<String> te...
Servlet+jsp开发图书管理系统流程。
qq_36098284的博客
04-05 2万+
本人在学习Servlet+JSP时候，是直接看的一个40课时的实战项目。根据项目学习写这种项目时候的套路。学习了包括如何分层，数据结构的使用，文件，接口的整理，还有servlet+jsp的基础知识等。本文主要介绍的是Servlet+jsp 开发图书管理系统的流程。有关servlet和jsp的基础知识在我的博客中有很多学习笔记可以参考。我都是分模块介绍的。稍后我还会写一个文章是描述MVC模式的。下面...
java （5）如何通过命令行来传递参数
qq_36098284的博客
08-15 1万+
今天在写一个作业，不让用scanner接收数据，要用args[ ]的数组。 public static void main(String args[]) 这一般是我写main这个类最常写的一句话，但是其实我也一直不知道那个String args[]写来是干什么的。但是今天就恰好用上了。 首先，贴一个代码，注意length参数和width参数的接收 //Determine if the a...
关于Java中子类调用父类方法
qq_36098284的博客
10-16 7041
https://blog.csdn.net/twilight_karl/article/details/53494296 本人在查看上面的文章的时候，发现，并不理解上面的输出情况。所以重新写了一篇文章进行解释。 代码如下。 package Temp; class A { int x = 6; private int y = 2; public A(int a) ...
"Java synchronized详解：保证线程安全的关键
本文档主要讲述的是java synchronized详解。Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。 第一篇：Java 语言的关键字，当它用来修饰一个方法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值