10-锁（synchronized和Lock）

已于 2023-08-29 16:51:22 修改
阅读量2.8k 收藏 18
点赞数 1
分类专栏： 多线程 文章标签： java
于 2023-02-22 01:37:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WWXDwrn/article/details/129115774
版权

目录

1.内置锁：synchronized（JVM中内置了）

1.1.synchronized基本用法

1.1.1.修饰静态方法（锁粒度太大，用得少）（不能修饰静态变量）

--->PS：上述代码中synchronized是如何保证线程安全问题的？

1.1.2.修饰普通方法（锁粒度太大，用得少）

1.1.3.修饰代码块（最常用）

--->PS：3种常用场景：

1.2.synchronized特性

1.2.1.互斥性/排他性

--->PS：公平锁 VS 非公平锁

1.2.2.刷新内存

1.2.3.可重入性

1.3.synchronized实现原理

（面试必问）synchronized是如何实现的？

1.3.1.监视器

1.3.2.底层实现

1.3.3.执行流程

1.4.synchronized历史发展进程

2.可重入锁/手动锁：Lock（Lock是一个接口,通常所说的可重入锁是指Lock的一个实现子类ReentrantLock)

2.1.Lock实现步骤：

①创建锁对象Lock lock = new ReentrantLock();

②加锁lock.lock();

③释放锁lock.unlock();

--->注意事项：

a.unlock()一定要放在finally里，否则可能导致锁资源永久占用问题。

b.lock()要放到try外（官方建议）或try中的首行（问题不大）。

2.2.Lock指定锁类型——公平锁和非公平锁

3.（面试必问）synchronized VS Lock（ReentrantLock）

①Lock 更灵活，有更多的方法，比如tryLock()。粒度可以更小（不明显）。

②Lock（接口级别）需要开发者手动操作锁（加/释放）；而 synchronized 是 JVM 层面提供的锁，自动进行加锁和释放锁操作，对于开发者是无感的。

③Lock 只能修饰代码块；而 synchronized 可以修饰普通方法、静态方法和代码块。

④锁类型不同：Lock 默认是非公平锁，但可以指定为公平锁；而 synchronized 只能是非公平锁。

⑤调用Lock和synchronized线程等待锁的状态不同：lock会变为WAITING；而synchronized会变为BLOCKED。

使用锁（最主要有以下2种）是Java中解决线程安全问题最主要的手段 。

1.内置锁：synchronized（JVM中内置了）

1.1.synchronized基本用法

1.1.1.修饰静态方法（锁粒度太大，用得少）（不能修饰静态变量）

public class ThreadSynchronized {
    //变量
    private static int number = 0;

    static class Counter{
        //循环次数
        private static int MAX_COUNT = 1000000;

        //++方法
        public synchronized static void incr() {
            for (int i = 0; i < MAX_COUNT; i++) {
                number++;
            }
        }

        //--方法
        public synchronized static void decr() {
            for (int i = 0; i < MAX_COUNT; i++) {
                number--;
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            Counter.incr();
        });
        t1.start();

        Thread t2 = new Thread(() -> {
            Counter.decr();
        });
        t2.start();

        t1.join();
        t2.join();
        System.out.println("最终的结果：" + number);
    }
}

--->PS：上述代码中synchronized是如何保证线程安全问题的？

  • 当使用synchronized给整个方法加锁时，其效率极低，甚至比单线程还慢。
  • 性能的好坏取决于synchronized修饰的范围，范围越大，安全性越高，性能越低；反之，锁的粒度越小，修饰的代码越少，安全性越低，性能越高。

1.1.2.修饰普通方法（锁粒度太大，用得少）

public class ThreadSynchronized2 {
    //变量
    private static int number = 0;

    static class Counter{
        //循环次数
        private static int MAX_COUNT = 1000000;

        //++方法
        public synchronized void incr() {
            for (int i = 0; i < MAX_COUNT; i++) {
                number++;
            }
        }

        //--方法
        public synchronized void decr() {
            for (int i = 0; i < MAX_COUNT; i++) {
                number--;
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread t1 = new Thread(() -> {
            counter.incr();
        });
        t1.start();

        Thread t2 = new Thread(() -> {
            counter.decr();
        });
        t2.start();

        t1.join();
        t2.join();
        System.out.println("最终的结果：" + number);
    }
}

1.1.3.修饰代码块（最常用）

public class ThreadSynchronized3 {
    //变量
    private static int number = 0;

    static class Counter{
        //循环次数
        private static int MAX_COUNT = 1000000;

        //++方法
        public void incr() {
            for (int i = 0; i < MAX_COUNT; i++) {
                synchronized (this) { //注意：synchronized (加锁的对象)，两个方法里加锁的对象要一样
                    number++;
                }
            }
        }

        //--方法
        public void decr() {
            for (int i = 0; i < MAX_COUNT; i++) {
                synchronized (this) { //注意：synchronized (加锁的对象)，两个方法里加锁的对象要一样
                    number--;
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread t1 = new Thread(() -> {
            counter.incr();
        });
        t1.start();

        Thread t2 = new Thread(() -> {
            counter.decr();
        });
        t2.start();

        t1.join();
        t2.join();
        System.out.println("最终的结果：" + number);
    }
}

--->PS：3种常用场景：

  1. this(非静态方法)
  2. xxx.class
  3. 自定义锁对象（更灵活，最常用）

①使用synchronized时，对于同一个业务的多个线程加锁对象，一定要是同一个对象（加同一把锁），否则加锁无效。

②synchronized修饰代码块，代码块在静态方法中时，不能使用this对象，否则会直接报错。

那么改为使用类型：

③自定义锁对象（普通/静态（加static）都可以）

1.2.synchronized特性

1.2.1.互斥性/排他性

synchronized（非公平锁）会起到互斥效果，某个线程执⾏到某个对象的 synchronized 中时，其他线程如果也执⾏到同⼀个对象 synchronized 就会阻塞等待。

  • 进⼊ synchronized 修饰的代码块, 相当于加锁。
  • 退出 synchronized 修饰的代码块, 相当于解锁。

--->PS：公平锁 VS 非公平锁

  • 公平锁：按资排辈，先到先得。需要“唤醒”这一步操作，会牺牲一定的性能。(线程发现锁占用，尝试获取锁一段时间后，进入休眠状态，进入排队队列中等待。上一个线程释放锁后，会唤醒排队等候的其他线程中最前面的线程从阻塞状态又切换至运行状态）
  • 非公平锁：来得早不如来得巧，不需要“唤醒”，性能高。（线程1发现锁占用，尝试获取锁一段时间后，进入休眠状态。此时线程2来了，处于运行状态，尝试获取锁，此时刚好上一个线程释放了锁，那么线程2直接得到了锁并去运行它的任务了。排队等待的其他线程获取锁的顺序不是按照访问的顺序先来先到的，而是由线程自己竞争，随机获取到锁）Java里所有的锁默认是非公平锁。

synchronized⽤的锁是存在Java对象头（隐藏的属性）⾥的：

Java中每个对象都有一个隐藏的对象头，它用来存储拥有当前锁的线程ID；它有一个标识，标识当前锁是被占用状态还是闲置状态。

  • 可粗略理解成, 每个对象在内存中存储时, 都存有⼀块内存（对象头）表示当前的 "锁定" 状态(类似于厕所的 "有⼈/⽆⼈")。
  • 如果当前是 "⽆⼈" 状态, 那么就可以使⽤, 使⽤时需要设为 "有⼈" 状态。
  • 如果当前是 "有⼈" 状态, 那么其他⼈⽆法使⽤, 只能排队。

理解 "阻塞等待"：

针对每⼀把锁，操作系统内部都维护了⼀个等待队列。当这个锁被某个线程占有的时候，其他线程尝试进⾏加锁，就加不上了，就会阻塞等待，⼀直等到之前的线程解锁之后，由操作系统唤醒⼀个新的线程，再来获取到这个锁。

注意：

上⼀个线程解锁之后，下⼀个线程并不是⽴即就能获取到锁，⽽是要靠操作系统来"唤醒"，这也就是操作系统线程调度的⼀部分⼯作。

假设有 A B C 三个线程，线程 A 先获取到锁，然后 B 尝试获取锁，然后 C 再尝试获取锁，此时B 和 C 都在阻塞队列中排队等待。但是当 A 释放锁之后，虽然 B ⽐ C 先来的，但是 B 不⼀定就能获取到锁，⽽是和 C 重新竞争，并不遵守先来后到的规则。

1.2.2.刷新内存

synchronized 的⼯作过程：

  1. 获得互斥锁。
  2. 从主内存拷贝变量的最新副本到⼯作的内存。
  3. 执⾏代码。
  4. 将更改后的共享变量的值刷新到主内存。
  5. 释放互斥锁。

所以 synchronized 也能保证内存可见性。

1.2.3.可重入性

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

/**
 * synchronized 可重入性测试
 */
public class ThreadSynchronized4 {
    public static void main(String[] args) {
        synchronized (ThreadSynchronized4.class) {
            System.out.println("当前主线程已经得到了锁"); //当执行到此行代码时，表示已经获得锁
            synchronized (ThreadSynchronized4.class) { //同一个线程获取锁两次
                System.out.println("当前主线程再次得到了锁"); //若两行代码都能打印，说明具备可重入性
            }
        }
    }
}

1.3.synchronized实现原理

（面试必问）synchronized是如何实现的？

①在Java代码层面：

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

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

  • 判断加锁标识为false->对象头未加锁，当前线程可以进入synchronized 修饰的代码块，并设置加锁标识为true，设置拥有当前锁的线程id为此线程id。
  • 判断加锁标识为true->对象头已加锁，需进一步判断拥有当前锁的线程id是否为此线程id，若是，则继续往下执行；否则，不能往下执行，需要等待锁资源释放后重新竞争再获取锁。

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

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

1.3.1.监视器

监视器是一个概念或者说是一个机制，它用来保障在任何时候，只有一个线程能够执行指定区域的代码。

一个监视器像是一个建筑，建筑里有一个特殊的房间，这个房间同一时刻只能被一个线程占有。

一个线程从进入该房间到离开该房间，可以全程独占该房间的所有数据。

  • 进入该建筑叫做进入监视器（entering the monitor）；
  • 进入该房间叫做获得监视器（acquiring the monitor）；
  • 独自占有该房间叫做拥有监视器（owing the monitor）；
  • 离开该房间叫做释放监视器（releasing the monitor）；
  • 离开该建筑叫做退出监视器（exiting the monitor）。

严格意义说，监视器和锁的概念是不同的，但很多地方将二者互相指代。

1.3.2.底层实现

查看字节码：

只能通过命令去看：

public class ThreadSynchronized5 {
    public static void main(String[] args) {
        synchronized (ThreadSynchronized5.class) {
            for (int i = 0; i < 10; i++) {
                System.out.println(i);
            }
        }
    }
}

源代码.java运行后就会在out目录下生成字节码文件.class，用命令查看字节码：

在字节码中，main方法中多了一对monitorenter和monitorexit指令，分别表示进入监视器和退出监视器。可知synchronized是依赖Monitor监视器实现的。

1.3.3.执行流程

在Java中，synchronized是非公平锁，也是可重入锁（指一个线程获取到锁之后，可以重复得到该锁）。

在HotSpot虚拟机（JVM的一种）中，Monitor底层是由C++实现的，它的实现对象是ObjectMonitor（隐藏的对象头），ObjectMonitor结构体的实现如下：

//结构体如下
ObjectMonitor::ObjectMonitor() {  
  _header       = NULL;  
  _count       = 0;  
  _waiters      = 0,  
  _recursions   = 0;       //线程的重入次数
  _object       = NULL;  
  _owner        = NULL;    //标识拥有该monitor的线程
  _WaitSet      = NULL;    //等待线程组成的双向循环链表，_WaitSet是第一个节点
  _WaitSetLock  = 0 ;  
  _Responsible  = NULL ;  
  _succ         = NULL ;  
  _cxq          = NULL ;    //多线程竞争锁进入时的单向链表
  FreeNext      = NULL ;  
  _EntryList    = NULL ;    //_owner从该双向循环链表中唤醒线程结点，_EntryList是第一个节点
  _SpinFreq     = 0 ;  
  _SpinClock    = 0 ;  
  OwnerIsThread = 0 ;  
}

以上代码中几个关键属性：

  1. _count：记录该线程获取锁的次数。
  2. _recursions：线程重入锁的次数。
  3. _owner：拥有者，是持有该ObjectMonitor（监视器）对象的线程，记录的是线程id。
  4. _EntryList：监控集合，存放的是处于阻塞状态的线程队列，在多线程下，竞争失败的线程会进入EntryList队列。
  5. _WaitSet：待授权集合，存放的是处于wait状态的线程队列，当线程执行了wait()方法之后，会进入WaitSet队列。

监视器执行流程如下：

  1. 线程通过CAS（是乐观锁里的一个对比并替换机制）尝试获取锁，如果获取成功，就将owner字段设置为当前线程，说明当前线程已经持有锁，并将recursions重入次数的属性+1。如果获取失败，则先通过自旋CAS尝试获取锁，如果还是失败则将当前线程放入到EntryList监控队列（阻塞）。
  2. 当拥有锁的线程执行了wait方法之后，线程释放锁，将owner变量恢复为null状态，同时将该线程放入WaitSet待授权队列中等待被唤醒。
  3. 当调用notify方法时，随机唤醒WaitSet队列中的某一个线程，当调用notifyAll时，唤醒所有的WaitSet中的线程尝试获取锁。
  4. 线程执行完释放了锁之后，会唤醒EntryList中的所有线程尝试获取锁。

1.4.synchronized历史发展进程

  • 在JDK1.6之前（多使用Lock）synchronized使用很少，那时synchronized默认使用重量级锁实现，所以性能较差。
  • 在JDK1.6时，synchronized做了优化。锁升级流程如下：
  1. 无锁：没有线程访问时默认是无锁状态，加了synchronized也是无锁状态。有线程访问时才加锁。更大程度上减少锁带来的程序上的开销。
  2. 偏向锁：当有一个线程访问时会升级为偏向锁。(在对象头里存了这样一把锁，后面再来线程时会判断，如果线程id和拥有锁的线程id相同，会让它进去，只偏向某一个线程，其他线程来了之后要继续等)
  3. 轻量级锁：当有多个线程访问时会升级为轻量级锁。
  4. 重量级锁：当有更多线程访问时会升级为重量级锁。
  • Oracle也有设计锁降级的功能。当线程访问变少时，会由重量级锁->降级为轻量级锁->偏向锁->无锁。但是这个机制目前还没有完善，只是有一个设计的思想和理念。

锁升级/降级就好比HashMap在JDK1.8之后底层实现：数组+链表/红黑树（存储结构的升级/降级）

  • 当数组长度>8且链表长度>64，会将链表升级为红黑树。
  • 当数组长度<8且链表长度<64，会将红黑树降级为链表。

2.可重入锁/手动锁：Lock（Lock是一个接口,通常所说的可重入锁是指Lock的一个实现子类ReentrantLock)

比synchronized更灵活，功能更多~

2.1.Lock实现步骤：

①创建锁对象Lock lock = new ReentrantLock();

②加锁lock.lock();

③释放锁lock.unlock();

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 手动锁（可重入锁的基本使用）
 */
public class ThreadLock {
    public static void main(String[] args) {
        //1.创建锁对象
        Lock lock = new ReentrantLock();
        //2.加锁操作
        lock.lock();
        try{
            //业务代码（可能会非常复杂->可能会导致异常，后面的代码就不执行了，锁就无法释放，当前线程会永久占用锁资源）
            //所以要用try-catch-finally（可以没有catch）
            System.out.println("你好，ReentrantLock.");
        } finally {
            //3.释放锁（一定要放在finally中）
            lock.unlock(); 
        }
    }
}

--->注意事项：

a.unlock()一定要放在finally里，否则可能导致锁资源永久占用问题。

b.lock()要放到try外（官方建议）或try中的首行（问题不大）。

oracle官方文档中的说明https://docs.oracle.com/javase/8/docs/api/

lock.lock();  
try {
    
} finally {
    lock.unlock()
}
try {
    lock.lock(); 
    int n = 1/0; 
} finally {
    lock.unlock()
}

↓不行：

try {
    int n = 1/0;
    lock.lock();  
} finally {
    lock.unlock()
}
原因有两个：
  1. 如果放在 try ⾥⾯，因为 try 代码中的异常导致加锁失败，但还会执行 finally 释放锁的操作。 未加锁却释放锁，肯定会报错。
  2. 报错信息中：unlock 异常会覆盖 try ⾥⾯的业务异常，从而增加调式程序和修复程序的复杂度，增加排查错误的难度。 

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ThreadLock2 {
    private static int number = 0;

    static class Counter{
        //1.创建锁对象
        private static Lock lock = new ReentrantLock();

        //循环次数
        private static int MAX_COUNT = 1000000;

        //++方法
        public static void incr() {
            for (int i = 0; i < MAX_COUNT; i++) {
                lock.lock(); //2.加锁
                try{
                    number++;
                } finally {
                    lock.unlock(); //3.释放锁
                }
            }
        }

        //--方法
        public static void decr() {
            for (int i = 0; i < MAX_COUNT; i++) {
                lock.lock();
                try{
                    number--;
                } finally {
                    lock.unlock();
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            Counter.incr();
        });
        t1.start();

        Thread t2 = new Thread(() -> {
            Counter.decr();
        });
        t2.start();

        t1.join();
        t2.join();
        System.out.println("最终的结果：" + number);
    }
}

2.2.Lock指定锁类型——公平锁和非公平锁

查看源码：

//1.创建锁对象
Lock lock = new ReentrantLock(true); //公平锁
Lock lock = new ReentrantLock(); //非公平锁
Lock lock = new ReentrantLock(false); //非公平锁

使用公平锁比使用非公平锁要慢！

3.（面试必问）synchronized VS Lock（ReentrantLock）

①Lock 更灵活，有更多的方法，比如tryLock()。粒度可以更小（不明显）。

boolean result = lock.tryLock(); //判断拿这个锁是否成功
boolean result = lock.tryLock(5, TimeUnit.SECONDS); //设置最大等待时间和单位，最多等5s，5s后如果还是没拿到锁，就不等了，返回false
//设置动态等待时间
for (int i = 0; i < 15; i++) {
   boolean result = lock.tryLock(1 + i, TimeUnit.SECONDS);
}
//第一次设置最大等待时间为1s，如果1s后没有获取到锁，继续循环，下一次最大等待时间就是2s，如果没得到，第3次就等待3s.
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ThreadLock4 {
    public static void main(String[] args) throws InterruptedException {
        Lock lock = new ReentrantLock();

//        synchronized (lock) { //如果获取锁失败会死等，直到拿到锁，执行业务代码
//
//        }

        boolean result = lock.tryLock(5, TimeUnit.SECONDS);
        if(result) {
            //获取锁成功，执行相应的代码

        } else {
            //获取锁失败，执行相应的业务
            //可以灵活处理，可以不等这个锁了，执行其他的业务操作；或回到最初代码，再去执行拿锁操作。可以人为控制。

        }
    }
}

②Lock（接口级别）需要开发者手动操作锁（加/释放）；而 synchronized 是 JVM 层面提供的锁，自动进行加锁和释放锁操作，对于开发者是无感的。

③Lock 只能修饰代码块；而 synchronized 可以修饰普通方法、静态方法和代码块。

④锁类型不同：Lock 默认是非公平锁，但可以指定为公平锁；而 synchronized 只能是非公平锁。

⑤调用Lock和synchronized线程等待锁的状态不同：lock会变为WAITING；而synchronized会变为BLOCKED。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ThreadLock4 {
    public static void main(String[] args) throws InterruptedException {
        Lock lock = new ReentrantLock();

        Thread t1 = new Thread(() -> {
           lock.lock();
            System.out.println("线程1得到了锁");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.println("线程1释放锁");
                lock.unlock();
            }
        });
        t1.start();

        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            lock.lock();
            try{
                System.out.println("线程2得到了锁");
            } finally {
                System.out.println("线程2释放锁");
                lock.unlock();
            }
        });
        t2.start();

        t1.join();
        t2.join();
    }
}

Lock：

public class ThreadLock4 {
    public static void main(String[] args) throws InterruptedException {
        Lock lock = new ReentrantLock();

        Thread t1 = new Thread(() -> {
           lock.lock();
            System.out.println("线程1得到了锁");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.println("线程1释放锁");
                lock.unlock();
            }
        });
        t1.start();

        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            lock.lock();
            try{
                System.out.println("线程2得到了锁");
            } finally {
                System.out.println("线程2释放锁");
                lock.unlock();
            }
        });
        t2.start();

        Thread.sleep(1500);
        System.out.println("线程2的状态：" + t2.getState());

        t1.join();
        t2.join();
    }
}

synchronized：

public class ThreadLock4 {
    public static void main(String[] args) throws InterruptedException {
        Lock lock = new ReentrantLock();

        Thread t1 = new Thread(() -> {
            synchronized (ThreadLock4.class) {
                System.out.println("线程1得到了锁");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程1释放锁");
            }
        });
        t1.start();

        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (ThreadLock4.class) {
                System.out.println("线程2得到了锁");
                System.out.println("线程2释放锁");
            }
        });
        t2.start();

        Thread.sleep(1500);
        System.out.println("线程2的状态：" + t2.getState());

        t1.join();
        t2.join();
    }
}

Lock和synchronized线程2都不是runnable运行状态。因为如果一直让线程2尝试获取锁，就会造成资源的浪费。

X-musk
关注
  • 1
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第5 章 Consul服务注册与发现
a13763926743的博客
04-22 747
consul官网地址。
再也不怕面试官问：详解Synchronized和Lock的实现原理及使用场景
Hanko的专栏
04-18 439
一般情况建议使用Synchronized，在JDK1.5之前Lock优于Synchronized，但在JDK1.5之后对Synchronized进行了优化，后面在性能方面基本与Lock一样且使用简单(有作者说"Synchronized是亲生的，JDK还是会一直优化他不会让Lock优于它")。
Synchronized 和 Lock 的区别和使用场景
01-20
并发编程中，锁是经常需要用到的，今天我们一起来看下Java中的锁机制：synchronized和lock。 Synchronized 和 Lock的概念 Synchronized 是Java 并发编程中很重要的关键字，另外一个很重要的是 volatile。Syncronized 的目的是一次只允许一个线程进入由他修饰的代码段，从而允许他们进行自我保护。Synchronized 很像生活中的锁例子，进入由Synchronized 保护的代码区首先需要获取 Synchronized 这把锁，其他线程想要执行必须进行等待。Synchronized 锁住的代码区域执行完成后需要把锁归还，也就是释放锁，
JAVA 中 13 种锁的实现方式
qq_43842093的博客
03-05 1521
分布式系统时代，线程并发，资源抢占，慢慢变得很重要。那么常见的锁都有哪些？
lock锁，lock锁和synchronized的对比
11-19
lock锁，lock锁和synchronized的对比 # Lock锁 JDK5.0后Java提供了一种更加强大的线程同步机制。一种显式定义同步锁对象来实现锁，提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock锁。 # synchronized锁与lock锁的对比 Lock是显式锁，需要手动的开启和关闭，synchronized锁是隐式锁，只要出了作用域就会自动释放。Lock只有代码块锁，synchronized既有代码块锁还有方法锁。 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。有更好的拓展性（可以提供更多的子类）。 Lock锁>同步代码块（已将进入了方法体，分配了相应的资源）>同步方法（在方法体外）
史上最全 Java 中各种锁的介绍
龚礼鹏的博客
06-16 4857
转载自：https://www.jianshu.com/p/94cf9ebd8932 Java提供了种类丰富的锁，每种锁因其特性的不同，在适当的场景下能够展现出非常高的效率。本文旨在对锁相关源码（本文中的源码来自JDK 8）、使用场景进行举例，为读者介绍主流锁的知识点，以及不同的锁的适用场景。 Java中往往是按照是否含有某一特性来定义锁，我们通过特性将锁进行分组归类，再使用对比的方式进行介绍，帮助大家更快捷的理解相关知识。下面给出本文内容的总体分类目录： 1. 乐观锁 VS 悲观锁# 乐.
Java锁
夏目川城的博客
03-24 1099
Java锁是什么？为什么要用Java锁？ 在并发编程中，经常遇到多个线程访问同一个共享资源 ，这时候作为开发者必须考虑如何维护数据一致性，在java中synchronized关键字被常用于维护数据一致性。synchronized机制是给共享资源上锁，只有拿到锁的线程才可以访问共享资源，这样就可以强制使得对共享资源的访问都是顺序的，因为对于共享资源属性访问是必要也是必须的。 一般在java中所说的锁...
Java锁机制，synchronized和lock详解。
记录开发日常笔记
08-16 6801
Java锁机制详解
synchronized 和 Lock详解总结
闫兆昌的博客
04-27 3751
1 synchronized 和 Lock的区别 a)存在层次 synchronized是关键字，在jvm层面上，由内置语言实现。 Lock是接口、类。 b) 锁的释放 synchronized在线...
JAVA各种锁的使用与原理专题(附源码讲义)
12-15
Java提供了种类丰富的锁，每种锁因其特性的不同，在适当的场景下能够展现出非常高的效率。本文旨在对锁相关源码（本文中的源码来自JDK8）、使用场景进行举例，为读者介绍主流锁的知识点，以及不同的锁的适用场景。 Java中往往是按照是否含有某一特性来定义锁，我们通过特性将锁进行分组归类，再使用对比的方式进行介绍，帮助大家更快捷的理解相关知识。帮助大家剖析JAVA中各种锁的底层原理，例如Synchronized锁的膨胀与升级等，掌握企业面试中各种锁的面试题，胜任企业开发。 下面给出课程内容的总体分类目录：  
一文带你彻底了解synchronized 和 Lock
zhiyikeji的博客
08-08 1872
synchronize在语义上很清晰，可以进行很多优化，有适应自旋，锁消除，锁粗化，轻量级锁，偏向锁等等。的时候，是会消耗CPU资源的。所以自旋必须要有一定的条件控制，否则如果一个线程执行同步代码块的时间很长，那么等待锁的线程会不断的循环反而会消耗CPU资源。在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要。在需要同步的对象中加入此控制，synchronized可以加在方法上，也可以加在特定代码块中，括号中表示需要锁的对象。...
Java中15种锁介绍
2301_78008478的博客
06-13 2714
lock（)方法利用的CAS，当第一个线程A获取锁的时候，能够成功获取到，不会进入while循环，如果此时线程A没有释放锁，另一个线程B又来获取锁，此时由于不满足CAS，所以就会进入while循环，不断判断是否满足CAS，直到A线程调用unlock方法释放了该锁。代码也比较简单，使用原子引用来存放线程，同一线程两次调用lock()方法，如果不执行unlock()释放锁的话，第二次调用自旋的时候就会产生死锁，这个锁就不是可重入的，而实际上同一个线程不必每次都去释放锁再来获取锁，这样的调度切换是很耗资源的。
关于synchronized、Lock的深入理解
12-21
目录synchronized的缺陷Lock和ReentrantLock常用方法ReadWriteLock和ReentrantReadWriteLockLock和synchronized区别synchronized锁升级公平锁和非公平锁 synchronized的缺陷 众所周知，synchronized锁是JAVA的关键字...
synchronized和LOCK的实现原理深入JVM锁机制比较好.docx
07-09
synchronized和LOCK的实现原理深入JVM锁机制比较好.docx
线程同步Synchronized，监视器monitor和锁lock的关系2---马克-to-win java视频
06-10
线程同步Synchronized，监视器monitor和锁lock的关系2---马克-to-win java视频
mybatisPlus使用MetaObjectHandler对字段进行更新
最新发布
m0_56356631的博客
04-23 263
都是符合我们的预期的。
string模拟实现
m0_73969414的博客
04-23 1393
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 521
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
javaweb-SpringBoot基础
kussm_的博客
04-20 1292
Spring的官网(Spring的简介：Spring makes Java simple。Spring Boot 可以帮助我们非常快速的构建应用程序、简化开发、提高效率。创建一个子包controller。
synchronized和lock锁区别
07-27
synchronized和lock锁是Java中用于实现线程同步的两种不同机制。 1. synchronized关键字是Java语言提供的内置机制，用于保证代码块或方法在同一时刻只能由一个线程执行。synchronized关键字可以用于修饰代码块或方法，当一个线程进入synchronized代码块或方法时，会自动获取锁，并在执行完毕后释放锁。synchronized关键字的锁是隐式的，由Java虚拟机自动管理。 2. Lock接口是Java.util.concurrent包提供的显式锁机制，也是一种更灵活、可控制性更强的锁机制。Lock接口的实现类可以通过调用lock()方法获取锁，并通过调用unlock()方法释放锁。与synchronized不同，Lock接口可以实现更细粒度的锁定，并提供了更多高级功能，如可重入锁、读写锁等。 下面是synchronized和Lock锁之间的一些区别： - 可重入性：synchronized是可重入锁，即一个线程可以多次获取同一个锁；而Lock接口可以通过实现ReentrantLock类来实现可重入锁。 - 锁的获取方式：synchronized关键字是隐式的，在进入synchronized代码块或方法时自动获取锁，并在退出时释放锁；而Lock接口需要显式地调用lock()方法获取锁，并在finally块中调用unlock()方法释放锁。 - 等待可中断：通过Lock接口提供的lockInterruptibly()方法，可以在等待获取锁的过程中响应中断请求，而synchronized关键字在等待获取锁时无法响应中断。 - 公平性：Lock接口可以实现公平锁，即按照线程请求锁的顺序来获取锁，而synchronized关键字是非公平锁。 - 性能：在低竞争情况下，synchronized关键字的性能表现更好；而在高竞争情况下，Lock接口的性能更好。 总的来说，synchronized是一种简单易用的线程同步机制，适用于大部分场景；而Lock接口提供了更多灵活、可控制的锁定方式，适用于一些特殊需求的场景。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值