synchronized的三种应用方式
synchronized关键字最主要有以下3种应用方式,下面分别介绍:
- 修饰实例方法,作用于当前实例加锁,进入同步代码前要获得当前实例的锁;
- 修饰静态方法,作用于当前类对象加锁,进入同步代码前要获得当前类对象的锁;
- 修饰代码块,指定加锁对象,对给定对象加锁,进入同步代码库前要获得给定对象的锁。
1.synchronized 修饰实例方法示例
/**
* synchronized 作用于实例方法
*/
public class SynchronizedTestOne implements Runnable {
private int inc = 0;
public int getInc() {
return inc;
}
public void setInc(int inc) {
this.inc = inc;
}
public synchronized void incryby() {
inc++;
}
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
incryby();
}
}
}
class Test {
public static void main(String[] args) throws InterruptedException {
SynchronizedTestOne synchronizedTestOne = new SynchronizedTestOne();
Thread thread1 = new Thread(synchronizedTestOne);
Thread thread2 = new Thread(synchronizedTestOne);
thread1.start();
thread2.start();
thread1.join();
thread2.join();
System.out.println(" inc output: " + synchronizedTestOne.getInc());
}
}
执行结果
inc output: 2000
如果在函数incryby()前不加synchronized,因为i++不具备原子性,所以最终结果会小于2000;
示例:
public class SynchronizedTestOne implements Runnable {
private int inc = 0;
public int getInc() {
return inc;
}
public void setInc(int inc) {
this.inc = inc;
}
public void incryby() {
inc++;
}
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
incryby();
}
}
}
class Test {
public static void main(String[] args) throws InterruptedException {
SynchronizedTestOne synchronizedTestOne = new SynchronizedTestOne();
Thread thread1 = new Thread(synchronizedTestOne);
Thread thread2 = new Thread(synchronizedTestOne);
thread1.start();
thread2.start();
thread1.join();
thread2.join();
System.out.println(" inc output: " + synchronizedTestOne.getInc());
}
}
执行结果
inc output: 1596
一个对象只有一把锁,当一个线程获取了该对象的锁之后,其他线程无法获取该对象的锁,所以无法访问该对象的其他synchronized实例方法,但是其他线程还是可以访问该实例对象的其他非synchronized方法。
但是一个线程 A 需要访问实例对象 obj1 的 synchronized 方法 f1(当前对象锁是obj1),另一个线程 B 需要访问实例对象 obj2 的 synchronized 方法 f2(当前对象锁是obj2),这样是允许的;
举例:
package com.dhcc.demo.springbootymldemo02.synctest;
/**
* synchronized 作用于实例方法
*/
public class SynchronizedTestTwo implements Runnable {
static int inc = 0;
public synchronized void incryby() {
inc++;
}
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
incryby();
}
}
public static void main(String[] args) throws InterruptedException {
SynchronizedTestTwo synchronizedTestOne = new SynchronizedTestTwo();
SynchronizedTestTwo synchronizedTestTwo = new SynchronizedTestTwo();
Thread thread1 = new Thread(synchronizedTestOne);
Thread thread2 = new Thread(synchronizedTestTwo);
thread1.start();
thread2.start();
thread1.join();
thread2.join();
System.out.println(" inc output: " + inc);
}
}
执行结果
inc output: 1993
上述代码与前面不同的是我们同时创建了两个SynchronizedTestTwo的新实例,然后启动两个不同的线程对共享变量inc进行操作,但操作结果是1993而不是期望结果2000,因为上述代码犯了严重的错误,虽然我们使用synchronized修饰了incryby方法,但却new了两个不同的实例对象,这也就意味着存在着两个不同的实例对象锁,因此t1和t2都会进入各自的对象锁,也就是说t1和t2线程使用的是不同的锁,因此线程安全是无法保证的。
每个对象都有一个对象锁,不同的对象,他们的锁不会互相影响。
解决这种困境的的方式是将synchronized作用于静态的incryby方法,这样的话,对象锁就当前类对象,由于无论创建多少个实例对象,但对于的类对象拥有只有一个,所有在这样的情况下对象锁就是唯一的。
2.synchronized作用于静态方法
当synchronized作用于静态方法时,其锁就是当前类的class锁,不属于某个对象。
当前类class锁被获取,不影响对象锁的获取,两者互不影响。
由于静态成员不专属于任何一个实例对象,是类成员,因此通过class对象锁可以控制静态成员的并发操作。需要注意的是如果一个线程A调用一个实例对象的非static修饰的synchronized方法,而线程B需要调用这个实例对象所属类的静态synchronized方法,不会发生互斥现象,因为访问静态synchronized方法占用的锁是当前类的class对象,而访问非静态synchronized方法占用的锁是当前实例对象锁;
public class StaticSynchronizedTest implements Runnable {
private static int inc=0;
/**
* 作用于静态方法,锁是当前class对象,也就是
* StaticSynchronizedTest类对应的class对象
*/
public static synchronized void incryByStatic(){
inc++;
}
// 非静态,访问时锁不一样时不会发生互斥
public synchronized void incryBy(){
inc++;
}
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
incryByStatic();
}
}
public static void main(String[] args) throws InterruptedException {
StaticSynchronizedTest staticSynchronizedTest1 = new StaticSynchronizedTest();
StaticSynchronizedTest staticSynchronizedTest2 = new StaticSynchronizedTest();
// StaticSynchronizedTest staticSynchronizedTest3 = new StaticSynchronizedTest();
Thread thread1 = new Thread(staticSynchronizedTest1);
Thread thread2 = new Thread(staticSynchronizedTest2);
// Thread thread3 = new Thread(()->{
// for (int i = 0; i < 1000; i++) {
// staticSynchronizedTest3.incryBy();
// }
// });
thread1.start();thread2.start();
// thread3.start();
thread1.join();thread2.join();
// thread3.join();
System.out.println(" inc output: " + inc);
}
}
执行结果
inc output: 2000
由于synchronized关键字修饰的是静态incryByStatic方法,与修饰实例方法不同的是,其锁对象是当前类的class对象。注意代码中的incryBy方法是实例方法,其对象锁是当前实例对象,如果别的线程调用该方法,将不会产生互斥现象,毕竟锁对象不同,但我们应该意识到这种情况下可能会发现线程安全问题(操作了共享静态变量i)。
示例:
public class StaticSynchronizedTest implements Runnable {
private static int inc=0;
/**
* 作用于静态方法,锁是当前class对象,也就是
* StaticSynchronizedTest类对应的class对象
*/
public static synchronized void incryByStatic(){
inc++;
}
// 非静态,访问时锁不一样时不会发生互斥
public synchronized void incryBy(){
inc++;
}
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
incryByStatic();
}
}
public static void main(String[] args) throws InterruptedException {
StaticSynchronizedTest staticSynchronizedTest1 = new StaticSynchronizedTest();
StaticSynchronizedTest staticSynchronizedTest2 = new StaticSynchronizedTest();
StaticSynchronizedTest staticSynchronizedTest3 = new StaticSynchronizedTest();
Thread thread1 = new Thread(staticSynchronizedTest1);
Thread thread2 = new Thread(staticSynchronizedTest2);
Thread thread3 = new Thread(()->{
for (int i = 0; i < 1000; i++) {
staticSynchronizedTest3.incryBy();
}
});
thread1.start();thread2.start();
thread3.start();
thread1.join();thread2.join();
thread3.join();
System.out.println(" inc output: " + inc);
}
}
执行结果
inc output: 2756
3.synchronized同步代码块
在某些情况下,我们编写的方法体可能比较大,同时存在一些比较耗时的操作,而需要同步的代码又只有一小部分,如果直接对整个方法进行同步操作,可能会得不偿失,此时我们可以使用同步代码块的方式对需要同步的代码进行包裹,这样就无需对整个方法进行同步操作了;
//1.使用对象锁,同步代码块块中为当前实例,测试同一实例对共享变量inc进行操作,结果为2000
public class SynchronizedTest implements Runnable {
public static int inc = 0;
@Override
public void run() {
synchronized (this) {
for (int i = 0; i < 1000; i++) {
inc++;
}
}
}
public static void main(String[] args) throws InterruptedException {
SynchronizedTest synchronizedTest = new SynchronizedTest();
Thread t1 = new Thread(synchronizedTest);
Thread t2 = new Thread(synchronizedTest);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(" inc output: " + inc);
}
}
执行结果
inc output: 2000
//2.使用对象锁,同步代码块块中为当前实例,测试不同实例对共享变量inc进行操作,结果为1544,线程安全是无法保证的
public class SynchronizedTest implements Runnable {
public static int inc = 0;
@Override
public void run() {
synchronized (this) {
for (int i = 0; i < 1000; i++) {
inc++;
}
}
}
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new SynchronizedTest());
Thread t2 = new Thread(new SynchronizedTest());
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(" inc output: " + inc);
}
}
执行结果
inc output: 1544
//3.使用class对象锁,无论创建多少个实例对象,但对于的类对象拥有只有一个,所有在这样的情况下对象锁就是唯一的,结果为2000
public class SynchronizedTest implements Runnable {
public static int inc = 0;
@Override
public void run() {
synchronized (SynchronizedTest.class) {
for (int i = 0; i < 1000; i++) {
inc++;
}
}
}
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new SynchronizedTest());
Thread t2 = new Thread(new SynchronizedTest());
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(" inc output: " + inc);
}
}
执行结果
inc output: 2000
从代码看出,将synchronized作用于一个给定的实例对象,即当前实例对象就是锁对象,每次当线程进入synchronized包裹的代码块时就会要求当前线程持有实例对象锁,如果当前有其他线程正持有该对象锁,那么新到的线程就必须等待,这样也就保证了每次只有一个线程执行i++;操作。我们还可以使用this对象(代表当前实例)或者当前类的class对象作为锁;
synchronized禁止指令重排分析
class MonitorExample {
int a = 0;
public synchronized void writer() { //1
a++; //2
} //3
public synchronized void reader() { //4
int i = a; //5
} //6
}
假设线程A执行writer()方法,随后线程B执行reader()方法。根据happens before规则,这个过程包含的happens before关系可以分为两类:
- 根据程序次序规则,1 happens before 2, 2 happens before 3; 4 happens before 5, 5 happens before 6。
- 根据监视器锁规则,3 happens before 4。
- 根据happens before的传递性,2 happens before 5。
上述happens before 关系的图形化表现形式如下:
在上图中,每一个箭头链接的两个节点,代表了一个happens before 关系。黑色箭头表示程序顺序规则;橙色箭头表示监视器锁规则;蓝色箭头表示组合这些规则后提供的happens before保证。
上图表示在线程A释放了锁之后,随后线程B获取同一个锁。在上图中,2 happens before 5。因此,线程A在释放锁之前所有可见的共享变量,在线程B获取同一个锁之后,将立刻变得对B线程可见。
synchronized的可重入性
从互斥锁的设计上来说,当一个线程试图操作一个由其他线程持有的对象锁的临界资源时,将会处于阻塞状态,但当一个线程再次请求自己持有对象锁的临界资源时,这种情况属于重入锁,请求将会成功;
synchronized就是可重入锁,因此一个线程调用synchronized方法的同时,在其方法体内部调用该对象另一个synchronized方法是允许的,如下:
public class AccountingSyncTest implements Runnable{
private static int a = 0;
private static int b = 0;
private synchronized void inncryBy(){
b++;
}
@Override
public void run() {
synchronized (this){
for (int i = 0; i < 1000; i++) {
a++;
inncryBy();
}
}
}
public static void main(String[] args) throws InterruptedException {
AccountingSyncTest accountingSyncTest = new AccountingSyncTest();
Thread t1 = new Thread(accountingSyncTest);
Thread t2 = new Thread(accountingSyncTest);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("a =" + a);
System.out.println("b =" + b);
}
}
执行结果
a =2000
b =2000
当前实例对象锁后进入synchronized代码块执行同步代码,并在代码块中调用了当前实例对象的另外一个synchronized方法,再次请求当前实例锁时,将被允许。需要特别注意另外一种情况,当子类继承父类时,子类也是可以通过可重入锁调用父类的同步方法。注意由于synchronized是基于monitor实现的,因此每次重入,monitor中的计数器仍会加1。