官方解释：
同步方法支持一种简单的策略来防止线程干扰和内存一致性错误：如果一个对象对多个线程可见，则对该对象变量的所有读取或写入都是通过同步方法完成的。
一句话总结出Synchronized的作用：
能够保证在同一时刻最多只有一个线程执行该段代码，以达到保证并发安全的效果
Synchronized的地位：
synchronized是Java的关键字，被Java语言原生支持
是最基本的互斥同步手段
synchronized的两个用法
对象锁：
包含方法锁（默认锁对象为this当前实力对象），同步代码块锁（自己制定锁对象）
类锁：
指sychronized修饰静态的方法或指锁为Class对象
第一个用法:对象锁
代码块形式:手动指定锁对象
方法锁形式:synchronized修饰普通方法,锁默认对象为this
第二个用法:类锁
概念:java类可能有有很多个对象,但是只有一个class对象
本质:所以所谓的类锁,不过是Class对象的锁而已
用法和效果:类锁只能在同一时刻被一个对象拥有
形式1:synchronized加载static方法上
形式2:synchronized(*.class)代码块
多线程访问同步方法的7种情况
1.两个线程同时访问一个对象的同步方法
串行
2.两个线程访问的是两个对象的同步方法
锁对象不同,互不干扰,并行
3.如果两个线程访问的是Synchronized的静态方法
串行
4.同时访问同步方法与非同步方法
并行
5.访问同一对象的不同的普通同步方法
同一对象锁,串行
6.同时访问静态synchronized和非静态synchronized方法
锁不同,并行
7.方法抛异常后,会释放锁吗
如果一个线程在进入同步方法后抛出了异常,则另一个线程会立刻进入该同步方法
7种情况的总结
1.一把锁只能同时被一个线程获取,没有拿到锁的线程必须等待(对应1,5种情况)
2.每个实例都对应有自己的一把锁,不同实例之间互不影响,例如,锁对象是*.class以及synchronized修饰的
是static方法的时候,所有对象共用同一把锁(对应第2,3,4,6种情况)
3.无论是方法正常执行完步或者方法抛出异常,都会释放锁(对应第7种情况)
性质
1.可重入
什么是可重入(递归锁)-----例如:Synchronized,ReentranLock
指的是同一线程的外层方法获得获得锁之后,内层方法可以直接在此获取该锁
例如: 买完车,需要摇号上车牌(锁),这样才能开车(执行相应的方法).
如果我有三辆车,但只有一个车牌,显然只能给一辆车上车牌----获取锁后只能执行一个方法
---------------为不可重入性
反之:一个车牌,三辆车都可以开
---------------为可重入性
好处:
避免死锁,提高封装性
粒度(范围):
可重入粒度测试: 证明线程而非调用(用三种情况来说明和pthread的区别)
情况一:证明同一方法是可重入的---递归调用本方法
package cn.cg;
/**
* 可重入测试----使用递归方式
* 情况1:同一个类中,同一方法可重入
*/
public class SynchronizedTest {
int i = 0;
//主线程可以重入以this为锁对象的method方法
public static void main(String[] args) {
SynchronizedTest s1 = new SynchronizedTest();
s1.method();
}
// 同步方法
private synchronized void method() {
if (i <=3) {
i++;
System.out.println(i);
method();
}
}
}
测试通过.
情况二:证明可重入不要求是同一个方法
package cn.cg;
/**
* 可重入测试----
* 情况2:同一个类中,不同方法可重入
*/
public class SynchronizedTest2 {
//主线程可以重入以this为锁对象的method方法
public static void main(String[] args) {
SynchronizedTest2 s1 = new SynchronizedTest2();
s1.method1();
}
// 同步方法
private synchronized void method1() {
System.out.println("method1");
method2();
}
private synchronized void method2() {
System.out.println("method2");
}
}
测试通过
情况三:证明可重入不要求是同一个类中的
public class Demo1 {
public synchronized void method(){
System.out.println("我是Demo1");
}
}
class Demo1Zi extends Demo1{
public synchronized void method(){
System.out.println("我是Demo1儿子");
super.method();
}
public static void main(String[] args) {
Demo1Zi zi = new Demo1Zi();
zi.method();
}
}
测试通过
2.不可中断
一旦这个锁已经被别人获得了,如果我还想获取,我只能选择等待或者阻塞,直到别的线程释放这个锁.如果别人永远不释放锁,那么我只能永远地等下去
相比之下,Lock类,可以拥有中断的能力,
第一点:如果我觉得我等的时间太长了,有权中断现在已经获取到锁的线程的执行,
第二点:如果我绝得我等待的时间太长不想再等了,也可以退出.
加锁和释放锁的原理
现象
每一个类的实例对应一把锁,每次调用被synchronized修饰的方法都必须首先获得该方法所属调用者实例的锁.否则线程阻塞,
方法一旦执行,该线程就独占了该锁知道该方法返回或者抛出异常,才能释放锁.
获取和释放锁的时机:内置锁(监视器锁)
等价代码
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Demo2 {
private Lock lock = new ReentrantLock();
public synchronized void method1(){
System.out.println("我是synchronized锁住的方法");
}
public void method2(){
//加锁
lock.lock();
try {
System.out.println("我是ReentranLock锁住的方法");
}finally {
lock.unlock();
}
}
public static void main(String[] args) {
Demo2 demo2 = new Demo2();
demo2.method1();
demo2.method2();
}
}
synchronized的缺点
1.效率低:锁的释放情况少,试图获得锁时不能设定超时,不能中断一个正在试图获得所得线程
2.不够灵活(读写锁更灵活):加锁和释放的时机单一,每个锁仅有单一的条件(某个对象),可能是不够的
3.无法知道是否成功获取到锁
标签：Synchronized,synchronized,对象,void,线程,方法,public,作用 From： https://www.cnblogs.com/nje19951205/p/17151479.html