1.原始构成
Synchronized是关键字属于JVM层面
monitorenter(底层通过monitor对象来完成,其实wait/notify等方法也依赖于monitor对象只有在同步块或方法中才能调用wait/notify 等方法 monitorexit
Lock是JUC下API层面下的锁
package com.concurrent;
import java.util.concurrent.locks.ReentrantLock;
/**
* synchronized 与 ReentrantLock() 区别
*/
public class SyncAndReentrantLockDemo {
public static void main(String[] args) {
synchronized (new Object()){
}
new ReentrantLock();
}
}
//javap 后的结果
Compiled from "SyncAndReentrantLockDemo.java"
public class com.concurrent.SyncAndReentrantLockDemo {
public com.concurrent.SyncAndReentrantLockDemo();
Code:
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return
public static void main(java.lang.String[]);
Code:
0: new #2 // class java/lang/Object
3: dup
4: invokespecial #1 // Method java/lang/Object."<init>":()V
7: dup
8: astore_1
9: monitorenter
10: aload_1
11: monitorexit
12: goto 20
15: astore_2
16: aload_1
17: monitorexit
18: aload_2
19: athrow
20: new #3 // class java/util/concurrent/locks/ReentrantLock
23: dup
24: invokespecial #4 // Method java/util/concurrent/locks/ReentrantLock."<init>":()V
27: pop
28: return
Exception table:
from to target type
10 12 15 any
15 18 15 any
}
2.使用方法
Synchronized不需要用户手动去释放锁,当synchronized代码执行完后系统会自动让线程对锁进行释放
ReentrantLock则需要手动去释放锁,如果没有主动去释放锁可能会出现死锁现象需要Lock,Unlock ,try - finally语句块完成
3.等待是否可中断
synchronized不可中断除非抛异常或者正常执行完成
ReentrantLock可以中断 1.设置超时方法 boolean tryLock(long time, TimeUnit unit)
2.void lockInterruptibly() throws InterruptedException; 放代码块中调用interrupt直接中断
4.加锁是否公平
Synchronized非公平锁
ReentrantLock两者都可以 默认非公平锁,构造方法可传入boolean值 true为公平锁,false为非公平锁
5.绑定多个条件的Condition
Synchronized根本没有
ReentrantLock用来实现分组可以唤醒需要唤醒的线程组,可以精确唤醒,而不是像Synchronized那一要么随机唤醒一个线程,要么全部唤醒
package com.concurrent;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* synchronized 与 ReentrantLock() 区别
*/
/**
* 多线程之间顺序调用 A--->B---->C---D
* <p>
* A打印5次,B打印10次,C15次
*/
class ShareReSource {
private int number = 1; //A:1 B:2 C:3
private Lock lock = new ReentrantLock();
private Condition c1 = lock.newCondition();
private Condition c2 = lock.newCondition();
private Condition c3 = lock.newCondition();
//1.判断
public void print5() {
lock.lock();
try {
while (number != 1) {
c1.await();
}
for (int i = 1; i <= 5; i++) {
System.out.println(Thread.currentThread().getName() + "\t" + i);
}
number = 2;
c2.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void print10() {
lock.lock();
try {
while (number != 2) {
c2.await();
}
for (int i = 1; i <= 10; i++) {
System.out.println(Thread.currentThread().getName() + "\t" + i);
}
number = 3;
c3.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void print15() {
lock.lock();
try {
while (number != 3) {
c3.await();
}
for (int i = 1; i <= 15; i++) {
System.out.println(Thread.currentThread().getName() + "\t" + i);
}
number = 1;
c1.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
//2.干活
//3.通知
}
public class SyncAndReentrantLockDemo {
public static void main(String[] args) {
ShareReSource shareReSource = new ShareReSource();
new Thread(() -> {
for (int i = 1; i < 5; i++) {
shareReSource.print5();
}
}, "A").start();
new Thread(() -> {
for (int i = 1; i < 10; i++) {
shareReSource.print10();
}
}, "B").start();
new Thread(() -> {
for (int i = 1; i < 15; i++) {
shareReSource.print15();
}
}, "C").start();
}
}
输出:
A 1
A 2
A 3
A 4
A 5
B 1
B 2
B 3
B 4
B 5
B 6
B 7
B 8
B 9
B 10
C 1
C 2
C 3
C 4
C 5
C 6
C 7
C 8
C 9
C 10
C 11
C 12
C 13
C 14
C 15
A 1
A 2
A 3
A 4
A 5
B 1
B 2
B 3
B 4
B 5
B 6
B 7
B 8
B 9
B 10
C 1
C 2
C 3
C 4
C 5
C 6
C 7
C 8
C 9
C 10
C 11
C 12
C 13
C 14
C 15
A 1
A 2
A 3
A 4
A 5
B 1
B 2
B 3
B 4
B 5
B 6
B 7
B 8
B 9
B 10
C 1
C 2
C 3
C 4
C 5
C 6
C 7
C 8
C 9
C 10
C 11
C 12
C 13
C 14
C 15
A 1
A 2
A 3
A 4
A 5
B 1
B 2
B 3
B 4
B 5
B 6
B 7
B 8
B 9
B 10
C 1
C 2
C 3
C 4
C 5
C 6
C 7
C 8
C 9
C 10
C 11
C 12
C 13
C 14
C 15