java中synchronized的使用和理解

最新推荐文章于 2024-03-03 21:02:09 发布
最新推荐文章于 2024-03-03 21:02:09 发布
阅读量346 收藏
点赞数 2
分类专栏： java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qdh186/article/details/78594279
版权

首先说一下Java的同步机制：保证在同一时间只有一个线程可以操作对应资源，避免多个线程同时访问相同资源发生冲突。synchronize是java中的一个关键字，它是一种同步锁，可以实现同步机制。
一：synchronized常用的几种方式：
1. synchronized修饰普通方法
2. synchronize修饰静态方法
3. synchronize修饰代码块
下面我把自己写的demo来进行说明
1:synchronized修饰普通方法

public class A {
	int num = -1;
	public A() {
		num = 0;
	}
	public synchronized void a() {
		for (int i = 0; i < 5; i++) {
			num += 1;
			try {
				Thread.sleep(10);			System.out.println(Thread.currentThread().getName() +">>>>>>>>>>"+ num);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

public class Main {
	public static void main(String[] args) {
		A a = new A();
	new Thread(new Runnable() {
		public void run() {
			a.a();
		}
	}).start();
	
	new Thread(new Runnable() {
		public void run() {
			a.a();
		}
	}).start();
	}
}

打印结果：
Thread-0>>>>>>>>>>1
Thread-0>>>>>>>>>>2
Thread-0>>>>>>>>>>3
Thread-0>>>>>>>>>>4
Thread-0>>>>>>>>>>5
Thread-1>>>>>>>>>>6
Thread-1>>>>>>>>>>7
Thread-1>>>>>>>>>>8
Thread-1>>>>>>>>>>9
Thread-1>>>>>>>>>>10
恩，不错，确实是实现了在同一时间内，只有一个线程能访问对应的资源，其他的线程必须的等其结束了才能开始运行。
好，那么我修改一下main中的代码呢？

public class Main {
	public static void main(String[] args) {
		A a1 = new A();
		A a2= new A();
	new Thread(new Runnable() {
		public void run() {
			a1.a();
		}
	}).start();
	
	new Thread(new Runnable() {
		public void run() {
			a2.a();
		}
	}).start();
	}
}

打印出来的结果是:
Thread-0>>>>>>>>>>1
Thread-1>>>>>>>>>>1
Thread-0>>>>>>>>>>2
Thread-1>>>>>>>>>>2
Thread-0>>>>>>>>>>3
Thread-1>>>>>>>>>>3
Thread-1>>>>>>>>>>4
Thread-0>>>>>>>>>>4
Thread-0>>>>>>>>>>5
Thread-1>>>>>>>>>>5
咦，这个结果怎么是这样？可以看出两个线程开启后，开始进行交叉运行。这样不对啊！！！应该等第一个线程结束，第二个线程才能开始运行啊。那么问题就来了，那么我就开始说一下这个事情。
synchronize修饰普通的方法时，是对象锁。也就是说在多线程中使用同一个对象访问synchronized修饰的方法可以达到同步的效果。但是如果在不同的线程中使用不同对象去调用其修饰的方法则达不到同步的效果。

2.修饰静态方法

public class A {
	static int num = -1;
	byte[] lock = new byte[0];
	public A() {
		num = 0;
	}
	public static synchronized void a() {
		for (int i = 0; i < 5; i++) {
			num += 1;
			try {
				Thread.sleep(10);
				System.out.println(Thread.currentThread().getName() + ">>>>>>>>>>"
						+ num);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		
		}
	}

public class Main {
	public static void main(String[] args) {
	new Thread(new Runnable() {
		public void run() {
			A.a();
		}
	}).start();
	
	new Thread(new Runnable() {
		public void run() {
			A.a();
		}
	}).start();
	}
}

打印结果：
Thread-0>>>>>>>>>>0
Thread-0>>>>>>>>>>1
Thread-0>>>>>>>>>>2
Thread-0>>>>>>>>>>3
Thread-0>>>>>>>>>>4
Thread-1>>>>>>>>>>5
Thread-1>>>>>>>>>>6
Thread-1>>>>>>>>>>7
Thread-1>>>>>>>>>>8
Thread-1>>>>>>>>>>9
synchronized修饰的静态方法，这种情况下的锁是包含这个方法的类的锁，也是这个类对象的锁。所以多线程访问时，可以达到同步的效果。
3.修饰代码块

public class A {
	static int num = -1;
	byte[] lock = new byte[0];

	public A() {
		num = 0;
	}
	public void printfLog() {
		synchronized (lock) {
			for (int i = 0; i < 5; i++) {
				num += 1;
				try {
					Thread.sleep(10);
		System.out.println(Thread.currentThread().getName()
							+ ">>>>>>>>>>" + num);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
	

public class Main {
	public static void main(String[] args) {
		A a1 = new A();
		A a2 = new A();
	new Thread(new Runnable() {
		public void run() {
			a1.printfLog();
		}
	}).start();
	
	new Thread(new Runnable() {
		public void run() {
			a2.printfLog();
		}
	}).start();
	}
}

打印结果：
Thread-0>>>>>>>>>>2
Thread-1>>>>>>>>>>3
Thread-0>>>>>>>>>>4
Thread-1>>>>>>>>>>5
Thread-0>>>>>>>>>>6
Thread-1>>>>>>>>>>7
Thread-0>>>>>>>>>>8
Thread-1>>>>>>>>>>9
Thread-0>>>>>>>>>>10
Thread-1>>>>>>>>>>10
这中结果和synchronize修饰的普通方法类似。在多线程中不同对象的进行调用，不能实现同步的效果。
注意：
1.在多线程中同一个对象进行调用，可以实现同步的效果 .可自行尝试一下。
2.将lock换成this时，打印的效果是一样的。
那么我将代码改动一下呢?

public class A {
	static int num = -1;
	byte[] lock = new byte[0];

	public A() {
		num = 0;
	}
	public void printfLog() {
		synchronized (A.class) {
			for (int i = 0; i < 5; i++) {
				num += 1;
				try {
					Thread.sleep(10);
					System.out.println(Thread.currentThread().getName()
							+ ">>>>>>>>>>" + num);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			
			}
		}
	}

打印结果如下:
Thread-0>>>>>>>>>>1
Thread-0>>>>>>>>>>2
Thread-0>>>>>>>>>>3
Thread-0>>>>>>>>>>4
Thread-0>>>>>>>>>>5
Thread-1>>>>>>>>>>6
Thread-1>>>>>>>>>>7
Thread-1>>>>>>>>>>8
Thread-1>>>>>>>>>>9
Thread-1>>>>>>>>>>10
所以这样的效果跟synchronize修饰静态方法一样。这样就可以在不同线程中不同的对象调用时实现同步的效果。

所以

synchronized 修饰方法 等价于 synchronized （this） { … } 都是对象锁
synchronized 修饰静态方法 等价于 synchronized(A.class){ … } 都是类的锁。

下面说一下synchronize修饰方法和代码块的区别：
synchronize修饰方法时，控制整个方法。
synchronize修饰代码块时，只控制代码块（只有代码块之内的才能实现同步效果）。而对于代码块之外的代码，则不受控制（也就是不能实现同步的效果）。
简单一点说就是：synchronize修饰代码块时，更加灵活精确。

二：synchronized支持可重入性

描述：一个同步方法调用另外一个同步方法(包括调用父类加锁的方法)，能否得到锁?

可以，synchronized本身可支持重入

代码如下：

public class Demo {

    synchronized void test1(){
        System.out.println("test1 start.........");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        test2();
        System.out.println("test1 end.........");
    }

    synchronized void test2(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("test2 start.......");
    }

    public static void main(String[] args) {
        Demo demo= new Demo();
        demo.test1();
    }

}

输出的结果如下：
test1 start…
test2 start…
test1 end…

3 synchronized 修饰普通方法时,如果出现异常，则会自动释放锁
证明如下：

public class Demo {

    int count = 0;

    synchronized void test(){
        System.out.println(Thread.currentThread().getName() + " start......");
        while (true) {
            count ++;
            System.out.println(Thread.currentThread().getName() + " count = " + count);
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 5) {
                //碰到异常的情况，如果没有处理，会自动释放锁，所以T2可以执行。
                int i = 1/0;
            }
        }
    }

    public static void main(String[] args) {
        Demo demo11 = new Demo();

        Runnable r = () -> demo11.test();

        new Thread(r, "t1").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(r, "t2").start();
    }

}

输出结果如下:
t1 start…
t1 count = 1
t1 count = 2
t1 count = 3
t1 count = 4
t1 count = 5
t2 start…
t2 count = 6
Exception in thread “t1” java.lang.ArithmeticException: / by zero
at com.luban.demo8.Demo.test(Demo.java:24)
at com.luban.demo8.Demo.lambda$main$0(Demo.java:32)
at java.lang.Thread.run(Thread.java:748)
t2 count = 7
t2 count = 8
t2 count = 9
t2 count = 10
… (t2会无线累加下去)

diligence-zpf
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中synchronized正确使用方法解析
08-25
本文将详细介绍 Java 中 synchronized 的正确使用方法，通过示例代码和实践案例，帮助读者深入理解 synchronized 的使用方法和原理。 一、并行和锁 并行是一种提高程序效率的方式，它允许多个线程同时执行，提高...
Java多线程--synchronized修饰普通方法和修饰静态方法的区别
学亮编程手记
05-09 1116
初始化一个对象时，会自动生成一个与该对象对应的对象锁，被synchronized 修饰的方法就得依靠对象锁工作。当多线程同时访问某个被synchronized修饰的方法时，一旦某个进程抢得对象锁之后，其他的进程只有排队对待。 一、synchronized修饰普通方法 初始化一个对象时，会自动生成一个与该对象对应的对象锁，被synchronized 修饰的方法就得依靠对象锁工作。当多线程同时...
synchronized修饰普通方法和静态方法
浪克oo的博客
03-25 910
两者区别： synchronized修饰普通方法：锁对象为当前实例对象(this) synchronized修饰静态方法：锁对象为当前类的字节码文件对象 具体例子如下： synchronized修饰普通方法 public class Animal { public synchronized void isDog() { Log.d("TAG", "isDog...
synchronized用法详解
最新发布
qq_43842093的博客
03-03 3187
synchronized 是 Java 中的关键字，是一种同步锁。主要应用于多线程环境下保证线程的安全性。A. 无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。B. 每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。C. 实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。
synchronized有几种用法？
q66562636的博客
04-15 3729
在 Java 语言中，保证线程安全性的主要手段是加锁，而 Java 中的锁主要有两种：synchronized 和 Lock，我们今天重点来看一下 synchronized 的几种用法。 用法简介 使用 synchronized 无需手动执行加锁和释放锁的操作，我们只需要声明 synchronized 关键字就可以了，JVM 层面会帮我们自动的进行加锁和释放锁的操作。 synchronized 可用于修饰普通方法、静态方法和代码块，接下来我们分别来看。 1、修饰普通方法 synchronized
4.3 方法上的 synchronized
白羊座的橙子
06-06 79
不加 synchronzied 的方法就好比不遵守规则的人，不去老实排队（好比翻窗户进去的）
深入理解java中的synchronized关键字
09-04
Java中的`synchronized`关键字是用于实现线程同步的关键机制，它的主要目的是确保在多线程环境中，对共享资源的访问能够保持数据的一致性和完整性。本文将深入探讨`synchronized`的两种主要用法：synchronized方法和...
Java 中 synchronized的用法详解(四种用法)
09-03
Java 中的 `synchronized` 关键字是多线程编程中的重要概念，用于实现线程同步，确保在并发环境下数据的一致性和完整性。下面将详细介绍 `synchronized` 的四种主要用法。 1. **修饰实例方法**： 当 `synchronized...
详解Java中synchronized关键字的死锁和内存占用问题
09-02
总之，理解和合理使用`synchronized`关键字是Java多线程编程中的基础，但同时也要注意避免潜在的死锁问题和过度使用导致的内存占用问题。正确选择同步机制，结合适当的并发工具，能够有效地提高多线程程序的效率和...
Java中synchronized实现原理详解
08-28
Java中的`synchronized`关键字是实现线程同步的关键，它的实现原理涉及到多个方面，包括Java对象头、Monitor（监视器锁）以及一系列的锁优化策略。本文将深入探讨这些概念。 首先，`synchronized`用于保证多线程...
透彻理解Java中Synchronized（对象锁）和Static Synchronized（类锁）的区别
08-27
主要介绍了Java中Synchronized（对象锁）和Static Synchronized（类锁）的区别，希望对大家有所帮助，一起跟随小编过来看看吧
Synchronized锁
T_karine的博客
12-06 3469
Synchronized锁原理及锁的升级过程
synchronized修饰普通方法，修饰静态方法比较
sqf251877543的博客
12-14 2546
转自：https://www.cnblogs.com/yanghuahui/p/3365922.html一、synchronized修饰普通方法初始化一个对象时，会自动生成一个与该对象对应的对象锁，于是该对象内部的被synchronized 修饰的方法就得依靠对象锁工作。当多线程同时访问某个被synchronized修饰的方法时，一旦某个进程抢得对象锁之后，其他的进程只有排队对待。例如，Person
synchronized（偏向锁和轻量级锁）（TODO）
anlao4870的博客
07-07 850
synchronized 　　JDK1.6对synchronized进行了各种优化，性能已经和ReentrantLock差不多了。 　　Java中的每一个对象都可以作为锁。具体表现为以下3种形式。 对于普通同步方法，锁是当前实例对象。 对于静态同步方法，锁是当前类的Class对象。 对于同步方法块，锁是Synchonized括号里配置的对象。 　　JVM基于进入和退出...
synchronized对静态方法，普通方法加锁的区别
qq_38842643的博客
10-12 1095
#synchronized通过售票的案例来分析 ##synchronized对普通方法加锁锁住的是当前对象，如果多个对象同时访问的时候无法保证线程。 ###对普通方法加锁 当有一个当有一个对象的时候运行结果：# ###多个对象的运行结果 我们可以发现出现了两次票数为6 ##对静态方法加锁 #不同对象运行结果 我们可以发现并没有上次的问题，一直是线程t1运行，线程t1占用类锁。 ...
java多线程（四）synchronized关键字修饰方法
xingjiarong的专栏
08-24 1万+
在之前的博客中我们介绍了条件对象和锁对象，两者结合使用才能起到比较好的互斥与同步效果，大家可能觉得有些麻烦，有没有将两者结合起来的工具呢，有！java提供了synchronized关键字来实现线程的互斥和同步，其达到的效果相当于条件对象和锁对象结合起来的效果。synchronized关键字有两类用法，一类是修饰方法，一类是修饰代码块，这篇博客主要介绍一下synchronized关键字修饰方法时的用
Synchronized同步静态方法和非静态方法总结
热门推荐
u010842515的博客
03-23 4万+
1.Synchronized修饰非静态方法，实际上是对调用该方法的对象加锁，俗称“对象锁”。        Java中每个对象都有一个锁，并且是唯一的。假设分配的一个对象空间，里面有多个方法，相当于空间里面有多个小房间，如果我们把所有的小房间都加锁，因为这个对象只有一把钥匙，因此同一时间只能有一个人打开一个小房间，然后用完了还回去，再由JVM 去分配下一个获得钥匙的人。 情况1：同一个
synchronized 修饰普通方法与静态方法的区别
HappyCode
12-07 1550
面试时候被问的问题，当时脑子里闪了一下，但是没答出来 先说结论： synchronized 修饰普通方法时，锁的是当前对象的方法，等价于 synchronized (this) synchronized 修饰静态方法时，锁的是所有对象的方法，等价于 synchronized （Xxx.class） 我们知道，普通方法从属于对象，而静态方法从属于类 带着疑惑，来看代码吧 情景1：当 synchronized 修饰 普通方法后，同一个对象被两个线程调用 结果 public class TestM.
理解Java中synchronized与Volatile的关键区别与用法
总结来说，这篇文档深入剖析了Java中`synchronized`的关键概念，帮助开发者理解和利用这一工具来编写高效、健壮的多线程代码。在实际编程中，正确地使用`synchronized`对于维护线程安全至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值