。

在Java当中被synchronized标记的代码或者方法在同一个时刻只能够有一个线程执行被synchronized修饰的方法或者代码块。

因此被synchronized修饰的方法或者代码块不会出现数据竞争的情况#x…一、什么是synchronized

在Java当中synchronized通常是用来标记一个方法或者代码块。

在Java当中被synchronized标记的代码或者方法在同一个时刻只能够有一个线程执行被synchronized修饰的方法或者代码块。

因此被synchronized修饰的方法或者代码块不会出现数据竞争的情况也就是说被synchronized修饰的代码块是并发安全的。

synchronized是java内置关键字,是内置锁,JVM中内置了,颗粒度比较大

2.1、修饰一个代码块

被修饰的方法称为同步方法其作用的范围是整个方法作用的对象是调用这个方法的对象;

非静态方法使用

其作用的范围是synchronized后面括号括起来的部分作用对象是这个类的所有对象。

三、使用案例分析

{syncDemo.add();}});t1.start();t2.start();t1.join();

//线程的阻塞方法,线程t1执行完毕,再执行main主线程打印语句t2.join();

//线程的阻塞方法,线程t2执行完毕,再执行main主线程打印语句System.out.println(syncDemo.count);}

由于add方法没有使用synchronized修饰线程t1和线程t2可能同时去执行add方法那么就会导致最终count的结果小于20000因为count操作不具备原子性。

public

由于add方法被synchronized修饰,因此每一个时刻只能有一个线程执行add方法因此上面打印的结果是20000

总结:

synchronized修饰的add方法一个时刻只能有一个线程执行的意思是对于一个SyncDemo类的对象来说一个时刻只能有一个线程进入。

比如现在有两个SyncDemo的对象s1和s2一个时刻只能有一个线程进行s1的add方法一个时刻只能有一个线程进入s2的add方法但是同一个时刻可以有两个不同的线程执行s1和s2的add方法也就说s1的add方法和s2的add是没有关系的一个线程进入s1的add方法并不会阻止另外的线程进入s2的add方法也就是说synchronized在修饰一个非静态方法的时候“锁”住的只是一个实例对象并不会“锁”住其它的对象。

其实这也很容易理解一个实例对象是一个独立的个体别的对象不会影响他他也不会影响别的对象。

class

{syncDemo.add();}});t1.start();t2.start();t1.join();

//线程的阻塞方法,线程t1执行完毕,再执行main主线程打印语句t2.join();

//线程的阻塞方法,线程t2执行完毕,再执行main主线程打印语句System.out.println(syncDemo.count);

//输出结果为2000}

上面的代码最终输出的结果也是20000但是与前一个程序不同的是。

这里的add方法用static修饰的在这种情况下真正只能有一个线程进入到add方法因为用static修饰的add方法是静态方法,静态方法所有对象公共的方法因此和前面的那种情况不同不存在两个不同的线程同一时刻执行不同实例对象的add方法。

你仔细想想如果能够让两个不同的线程执行add代码块那么count的执行就不是原子的了。

那为什么没有用static修饰的代码为什么可以呢因为当没有用static修饰时每一个对象的count都是不同的内存地址不一样因此在这种情况下count这个操作仍然是原子的

3.3、修饰一个代码块

{System.out.println(进入了add方法);synchronized

void

{System.out.println(进入了minus方法);synchronized

static

{syncDemo.minus();}});t1.start();t2.start();t1.join();

//线程的阻塞方法,线程t1执行完毕,再执行main主线程打印语句t2.join();

//线程的阻塞方法,线程t2执行完毕,再执行main主线程打印语句System.out.println(syncDemo.count);

//输出结果为0}

有时候我们并不需要用synchronized去修饰一个方法因为这样并发度就比较低了一个方法一个时刻只能有一个线程在执行。

因此我们可以选择用synchronized去修饰代码块只让某个代码块一个时刻只能有一个线程执行除了这个代码块之外的代码还是可以并行的。

比如上面的代码当中add和minus方法没有使用synchronized进行修饰因此一个时刻可以有多个线程执行这个两个方法。

在上面的synchronized代码块当中我们使用了this对象作为锁对象只有拿到这个锁对象的线程才能够进入代码块执行而在同一个时刻只能有一个线程能够获得锁对象。

也就是说add函数和minus函数用synchronized修饰的两个代码块同一个时刻只能有一个代码块的代码能够被一个线程执行因此上面的结果同样是0。

这里说的锁对象是this也就SyncDemo类的一个实例对象因为它锁住的是一个实例对象因此当实例对象不一样的时候他们之间是没有关系的也就是说不同实例用synchronized修饰的代码块是没有关系的他们之间是可以并发的。

3.4、修饰一个类

{System.out.println(进入了add方法);synchronized

(SyncDemo.class){count;}}public

void

{System.out.println(进入了minus方法);synchronized

(SyncDemo.class){count--;}}public

static

{syncDemo.minus();}});t1.start();t2.start();t1.join();

//线程的阻塞方法,线程t1执行完毕,再执行main主线程打印语句t2.join();

//线程的阻塞方法,线程t2执行完毕,再执行main主线程打印语句System.out.println(syncDemo.count);

//输出结果为0}

上面的代码是使用synchronized修饰类锁对象是SyncDemo.class,这个时候他不再是锁住一个对象了而是一个类了这个时候的并发度就变小了上一份代码当锁对象是SyncDemo的实例对象时并发度更大一些因为当锁对象是实例对象的时候只有实例对象内部是不能够并发的实例之间是可以并发的。

但是当锁对象是SyncDemo.class的时候实例对象之间时不能够并发的因为这个时候的锁对象是一个类。

4.1互斥性/排他性(非公平锁)

synchronized非公平锁会起到互斥效果某个线程执⾏到某个对象的

synchronized

公平锁按资排辈先到先得。

需要“唤醒”这一步操作会牺牲一定的性能。

(线程发现锁占用尝试获取锁一段时间后进入休眠状态进入排队队列中等待。

上一个线程释放锁后会唤醒排队等候的其他线程中最前面的线程从阻塞状态又切换至运行状态

非公平锁来得早不如来得巧不需要“唤醒”性能高。

线程1发现锁占用尝试获取锁一段时间后进入休眠状态。

此时线程2来了处于运行状态尝试获取锁此时刚好上一个线程释放了锁那么线程2直接得到了锁并去运行它的任务了。

排队等待的其他线程获取锁的顺序不是按照访问的顺序先来先到的而是由线程自己竞争随机获取到锁Java里所有的锁默认是非公平锁。

当一个线程进入到synchronized同步代码块的时候将会刷新所有对该线程的可见的变量也就是说如果其他线程修改了某个变量而且线程需要在Synchronized代码块当中使用那就会重新刷新这个变量到内存当中保证这个变量对于执行同步代码块的线程是可见的。

当一个线程从同步代码块退出的时候也会将线程的工作内存同步到内存当中保证在同步代码块当中修改的变量对其他线程可见。

synchronized

同步块对同⼀条线程来说是可重⼊的不会出现⾃⼰把⾃⼰锁死的问题。

/***

{System.out.println(当前主线程已经得到了锁);

//同一个线程获取锁两次System.out.println(当前主线程再次得到了锁);

五、synchronized实现原理

synchronized加锁的对象里有一个的隐藏的对象头这个对象头可看作一个类里有很多属性其中比较关注的两个属性是是否加锁的标识和拥有当前锁的线程id。

每次进⼊

修饰的代码块时会去对象头中先判断加锁的标识再判断拥有当前锁的线程id从而决定当前线程能否往下继续执行。

判断加锁标识为false-对象头未加锁当前线程可以进入synchronized

修饰的代码块并设置加锁标识为true设置拥有当前锁的线程id为此线程id。

判断加锁标识为true-对象头已加锁需进一步判断拥有当前锁的线程id是否为此线程id若是则继续往下执行否则不能往下执行需要等待锁资源释放后重新竞争再获取锁。

②在JVM层面和操作系统层面

synchronized同步锁是通过JVM内置的Monitor监视器实现的而监视器又是依赖操作系统的互斥锁Mutex实现的。

↓

————————————————

原文链接https://blog.csdn.net/WWXDwrn/article/details/129115774

六、synchronized历史发展进程

在JDK1.6之前多使用Locksynchronized使用很少那时synchronized默认使用重量级锁实现所以性能较差。

在JDK1.6时synchronized做了优化。

锁升级流程如下

1,无锁没有线程访问时默认是无锁状态加了synchronized也是无锁状态。

有线程访问时才加锁。

更大程度上减少锁带来的程序上的开销。

2,偏向锁当有一个线程访问时会升级为偏向锁。

(在对象头里存了这样一把锁后面再来线程时会判断如果线程id和拥有锁的线程id相同会让它进去只偏向某一个线程其他线程来了之后要继续等)

4,重量级锁当大量线程访问同时竞争锁资源的时候会升级为重量级锁。

原文链接https://baijiahao.baidu.com/s?id1740505389877266267wfrspiderforpc