一起养成写作习惯!这是我参与「掘金日新计划 · 4 月更文挑战」的第8天,点击查看活动详情
synchronized关键字的四种使用方法
1. 同步一个代码块
public void func1(){
// 同步代码块
synchronized (this){
//...
}
}
复制代码
它==只作用于同一个对象==,如果调用两个对象上的同步代码块不会同步
对于以下线程,由于调用同一个对象,所以实现了同步。
/**
* @Author 胡孟帆
* @Date 2021-11-21 15:58
* @Function
**/
@SpringBootTest
public class SynchronizedTests {
@Test
void contextLoads() {
}
public static void main(String[] args) {
SynchronizedExample e1 = new SynchronizedExample();
ExecutorService executorService = Executors.newCachedThreadPool();
// 同一个对象调用
executorService.execute(() -> e1.func1());
executorService.execute(() -> e1.func1());
}
public static class SynchronizedExample{
public void func1(){
// 同步代码块
synchronized (this){
for (int i = 0;i < 10;i++){
System.out.print(i + " ");
}
}
}
}
}
复制代码
由输出结果可知,当一个线程进入同步代码块时,另一个线程等待其结束才进入。
对于以下线程,由于调用不同对象,线程交叉执行。
public static void main(String[] args) {
SynchronizedExample e1 = new SynchronizedExample();
SynchronizedExample e2 = new SynchronizedExample();
// 不同对象调用
ExecutorService executorService = Executors.newCachedThreadPool();
executorService.execute(() -> e1.func1());
executorService.execute(() -> e1.func1());
}
复制代码
由于运行比较快,所以这里改成循环100次,输出结果发现两个线程交叉执行。
2. 同步一个方法
// 同步一个方法
public static class SynchronizedExample{
// 同步方法
public synchronized void func1(){
for (int i = 0;i < 100;i++){
System.out.print(i + " ");
}
}
}
复制代码
它和同步代码块一样,作用于同一个对象,不同对象交叉执行。
3. 同步一个类
public void func1(){
synchronized (SynchronizedExample.class){
for (int i = 0;i < 10;i++){
System.out.print(i + " ");
}
}
}
复制代码
作用于整个类,也就是说不同对象也会同步
4. 同步一个静态方法
public static class SynchronizedExample{
// 同步一个静态方法
public synchronized void func1(){
for (int i = 0;i < 10;i++){
System.out.print(i + " ");
}
}
}
复制代码
作用于一整个类,和同步代码块一样,作用于同一个对象,不同对象交叉执行。
ReentrantLock
ReentrantLock 是 java.util.concurrent (J.U.C) 包中的锁。
/**
* @Author 胡孟帆
* @Date 2021-11-21 17:06
* @Function
**/
public class LockTests {
public static void main(String[] args) {
LockTests lockTests = new LockTests();
ExecutorService executorService = Executors.newCachedThreadPool();
executorService.execute(() -> lockTests.func());
executorService.execute(() -> lockTests.func());
}
// 新建一个ReentrantLock对象
private Lock lock = new ReentrantLock();
public void func(){
// 上锁
lock.lock();
try {
for (int i = 0;i < 10; i++){
System.out.print( i+ " ");
}
}finally {
// 确保释放锁,避免发生死锁
lock.unlock();
}
}
}
复制代码
两者的比较
1、锁的实现
synchronized 是 JVM 实现的,而 ReentrantLock 是JDK实现的。
2、性能
新版本 Java 对 synchronized 进行了许多优化,比如自旋锁等,性能两者相当。
3、等待可中断
当持有锁的线程长期不释放锁的时候,正在等待的线程可以选择放弃等待,改为处理其他事情。 ReentrantLock 可以中断,而 synchronized 不行。
4、公平锁
公平锁是指多个线程再等待同一个锁时,必须按照申请锁的时间顺序来依次获得锁。 synchronzied 中的锁是非公平的,ReentrantLock 默认情况下也是非公平的,但也可以是公平的
5、锁绑定多个条件
一个 ReentrantLock 可以绑定多个 Condition 对象(鉴定完毕,大渣男)
6、使用选择
除非需要使用 ReentrantLock 的高级功能,否则==优先使用 synchronized==,这是因为 synchronized 是 JVM 实现的一种锁机制,JVM 原生地支持它,而 ReentrantLock 不是所有的 JDK 版本都支持,并且使用 synchronized 不用担心没有释放锁导致死锁问题,因为 JVM 会保存锁的释放