JUC的一些知识点

于 2022-05-11 22:24:15 发布
阅读量247 收藏
点赞数 1
分类专栏： 面试题 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A798194701/article/details/124720634
版权

1、什么是CAS

CAS的全称是Compare-And-Swap，意为：比较并替换，它是CPU并发原语

它的功能是判断内存某个位置的值是否为预期值，如果是则更改为新的值，这个过程是原子的

CAS并发原语体现在Java语言中就是sun.misc.Unsafe类的各个方法。调用UnSafe类中的CAS方法，JVM会帮我们实现出CAS汇编指令，这是一种完全依赖于硬件的功能，通过它实现了原子操作，再次强调，由于CAS是一种系统原语，原语属于操作系统用于范畴，是由若干条指令组成，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被中断，也就是说CAS是一条CPU的原子指令，不会造成所谓的数据不一致的问题，也就是说CAS是线程安全的。

代码使用

首先调用AtomicInteger创建了一个实例， 并初始化为5

        // 创建一个原子类
        AtomicInteger atomicInteger = new AtomicInteger(5);

然后调用CAS方法，企图更新成2019，这里有两个参数，一个是5，表示期望值，第二个就是我们要更新的值

atomicInteger.compareAndSet(5, 2019)

然后再次使用了一个方法，同样将值改成1024

atomicInteger.compareAndSet(5, 1024)

完整代码如下：

/**
 * CASDemo
 *
 * 比较并交换：compareAndSet
 *
 * @author: 陌溪
 * @create: 2020-03-10-19:46
 */
public class CASDemo {
    public static void main(String[] args) {
        // 创建一个原子类
        AtomicInteger atomicInteger = new AtomicInteger(5);

        /**
         * 一个是期望值，一个是更新值，但期望值和原来的值相同时，才能够更改
         * 假设三秒前，我拿的是5，也就是expect为5，然后我需要更新成 2019
         */
        System.out.println(atomicInteger.compareAndSet(5, 2019) + "\t current data: " + atomicInteger.get());

        System.out.println(atomicInteger.compareAndSet(5, 1024) + "\t current data: " + atomicInteger.get());
    }
}

上面代码的执行结果为

img

这是因为我们执行第一个的时候，期望值和原本值是满足的，因此修改成功，但是第二次后，主内存的值已经修改成了2019，不满足期望值，因此返回了false，本次写入失败

img

这个就类似于SVN或者Git的版本号，如果没有人更改过，就能够正常提交，否者需要先将代码pull下来，合并代码后，然后提交

CAS底层原理

首先我们先看看 atomicInteger.getAndIncrement()方法的源码

img

从这里能够看到，底层又调用了一个unsafe类的getAndAddInt方法。变量valueOffset表示该变量值在内存中的偏移地址，因为Unsafe就是根据内存偏移地址获取数据的。从这里我们能够看到，通过valueOffset，直接通过内存地址，获取到值，然后进行加1的操作

image-20200310203350122

Unsafe是CAS的核心类，由于Java方法无法直接访问底层系统，需要通过本地（Native）方法来访问，Unsafe相当于一个后门，基于该类可以直接操作特定的内存数据。Unsafe类存在sun.misc包中，其内部方法操作可以像C的指针一样直接操作内存，因为Java中的CAS操作的执行依赖于Unsafe类的方法。

注意Unsafe类的所有方法都是native修饰的，也就是说unsafe类中的方法都直接调用操作系统底层资源执行相应的任务

为什么Atomic修饰的包装类，能够保证原子性，依靠的就是底层的unsafe类

image-20200310210701761

var5：就是我们从主内存中拷贝到工作内存中的值(每次都要从主内存拿到最新的值到自己的本地内存，然后执行compareAndSwapInt()再和主内存的值进行比较。因为线程不可以直接越过高速缓存，直接操作主内存，所以执行上述方法需要比较一次，在执行加1操作)

那么操作的时候，需要比较工作内存中的值，和主内存中的值进行比较

假设执行 compareAndSwapInt返回false，那么就一直执行 while方法，直到期望的值和真实值一样（自旋锁思想）

  • val1：AtomicInteger对象本身
  • var2：该对象值得引用地址
  • var4：需要变动的数量
  • var5：用var1和var2找到的内存中的真实值
    • 用该对象当前的值与var5比较
    • 如果相同，更新var5 + var4 并返回true
    • 如果不同，继续取值然后再比较，直到更新完成

这里没有用synchronized，而用CAS，这样提高了并发性，也能够实现一致性，是因为每个线程进来后，进入的do while循环，然后不断的获取内存中的值，判断是否为最新，然后在进行更新操作。

假设线程A和线程B同时执行getAndInt操作（分别跑在不同的CPU上）

  1. AtomicInteger里面的value原始值为3，即主内存中AtomicInteger的 value 为3，根据JMM模型，线程A和线程B各自持有一份价值为3的副本，分别存储在各自的工作内存
  2. 线程A通过getIntVolatile(var1 , var2) 拿到value值3，这是线程A被挂起（该线程失去CPU执行权）
  3. 线程B也通过getIntVolatile(var1, var2)方法获取到value值也是3，此时刚好线程B没有被挂起，并执行了compareAndSwapInt方法，比较内存的值也是3，成功修改内存值为4，线程B打完收工，一切OK
  4. 这时线程A恢复，执行CAS方法，比较发现自己手里的数字3和主内存中的数字4不一致，说明该值已经被其它线程抢先一步修改过了，那么A线程本次修改失败，只能够重新读取后在来一遍了，也就是在执行do while
  5. 线程A重新获取value值，因为变量value被volatile修饰，所以其它线程对它的修改，线程A总能够看到，线程A继续执行compareAndSwapInt进行比较替换，直到成功。

Unsafe类 + CAS思想： 也就是自旋，自我旋转

CAS缺点

CAS不加锁，保证一次性，但是需要多次比较

  • 循环时间长，开销大（因为执行的是do while，如果比较不成功一直在循环，最差的情况，就是某个线程一直取到的值和预期值都不一样，这样就会无限循环）
  • 只能保证一个共享变量的原子操作
    • 当对一个共享变量执行操作时，我们可以通过循环CAS的方式来保证原子操作
    • 但是对于多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候只能用锁来保证原子性
  • 引出来ABA问题？

2、ABA问题

CAS的好处就是保证数据一致性的同时，还保证了并发性，CPU指令原语的原子性是指再修改的时候本线程不受其他线程干扰但其他线程也可随时修改主内存的变量值，由此便产生了ABA问题

image-20220424160932994

上述图片解释：

  1. 线程A和线程B同时获取到初始bia变量100
  2. A线程被挂起没有往下执行，B线程将变量改为101，并写回主内存
  3. 线程C获取线程B更改后的数据，将数据改回100
  4. 此时线程A开始执行，进行修改操作，期望值和主存内的值相同将会修改成功

👀 在A被挂起的这段时间内，主存中变量值发生的变化，对线程A是无感知的，也就是它不知道主存中的值被修改过了。

怎样解决？

使用AtomicStampedReference加版本号解决

有ABA问题的代码举例

 @Test
    public void ABADemo(){
        AtomicReference<Integer> atomicReference = new AtomicReference<>(100);

        new Thread(() -> {
            atomicReference.compareAndSet(100, 101);
            atomicReference.compareAndSet(101, 100);
        }, "t1").start();


        new Thread(() -> {
            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            boolean compareAndSet = atomicReference.compareAndSet(100, 2022);
            System.out.println(compareAndSet + "  " + atomicReference.get());
        }, "t2").start();
    }
/*
true  2022
*/

解决ABA问题的代码

   @Test
    public void UnABADemo(){
        AtomicStampedReference<Integer> stampedReference = new AtomicStampedReference<Integer>(100, 1);

        new Thread(() -> {
            System.out.println("初始版本号" + stampedReference.getStamp());
            stampedReference.compareAndSet(100, 101, stampedReference.getStamp(), stampedReference.getStamp() + 1);
            stampedReference.compareAndSet(101, 100, stampedReference.getStamp(), stampedReference.getStamp() + 1);
        }, "t1").start();

        new Thread(() -> {
            int stamp = stampedReference.getStamp();
            System.out.println("线程二获取版本号" + stamp);

            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            boolean b = stampedReference.compareAndSet(100, 2022, stamp, stamp + 1);
            System.out.println("是否更改成功"+b+" "+"当前数值"+stampedReference.getReference()+"当前事务号 "+stampedReference.getStamp());
        }, "T2").start();

    }
/*
初始版本号1
线程二获取版本号1
是否更改成功false 当前数值100当前事务号 3
*/

3、公平锁与非公平锁

公平锁

是指多个线程按照锁的申请顺序来获取锁，类似于排队买饭，先到先得先来先服务，不允许加塞，也就是队列

非公平锁

多个线程获取锁的顺序，并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁，在高并发的环境下，有可能造成优先级翻转，或饥饿的线程（也就是某一个线程一直得不到锁）

如何创建一个公平锁
/**
* 创建一个可重入锁，true 表示公平锁，false 表示非公平锁。默认非公平锁
*/
Lock lock = new ReentrantLock(true);

并发包中ReentrantLock的创建可以指定析构函数的boolean类型来得到公平锁或者非公平锁，默认是非公平锁，synchronized为不公平锁

公平锁与非公平锁的区别

公平锁：就是很公平，在并发环境中，每个线程在获取锁时会先查看此锁维护的等待队列，如果为空，或者当前线程是等待队列中的第一个，就占用锁，否则就会加入到等待队列中，以后安装FIFO的规则从队列中取到自己

非公平锁： 非公平锁比较粗鲁，上来就直接尝试占有锁，如果尝试失败，就再采用类似公平锁那种方式。

题外话

Java ReenttrantLock通过构造函数指定该锁是否公平，默认是非公平锁，因为非公平锁的优点在于吞吐量比公平锁大，对于synchronized而言，也是一种非公平锁

4、可重入锁和递归锁ReentrantLock

1、概念

可重入锁就是递归锁

指的是同一线程外层函数获得锁之后，内层递归函数仍然能获取到该锁的代码，在同一线程在外层方法获取锁的时候，在进入内层方法会自动获取锁

也就是说：线程可以进入任何一个它已经拥有的锁所同步的代码块

ReentrantLock / Synchronized 就是一个典型的可重入锁

2、代码

可重入锁就是，在一个method1方法中加入一把锁，方法2也加锁了，那么他们拥有的是同一把锁

public synchronized void method1() {
	method2();
}

public synchronized void method2() {

}

也就是说我们只需要进入method1后，那么它也能直接进入method2方法，因为他们所拥有的锁，是同一把。

3、作用

可重入锁的最大作用就是避免死锁

4、可重入锁验证
证明Synchronized
/**
 * 可重入锁（也叫递归锁）
 * 指的是同一线程外层函数获得锁之后，内层递归函数仍然能获取到该锁的代码，在同一线程在外层方法获取锁的时候，在进入内层方法会自动获取锁
 * 也就是说：`线程可以进入任何一个它已经拥有的锁所同步的代码块`
 */

/**
 * 资源类
 */
class Phone {

    /**
     * 发送短信
     * @throws Exception
     */
    public synchronized void sendSMS() throws Exception{
        System.out.println(Thread.currentThread().getName() + "\t invoked sendSMS()");

        // 在同步方法中，调用另外一个同步方法
        sendEmail();
    }

    /**
     * 发邮件
     * @throws Exception
     */
    public synchronized void sendEmail() throws Exception{
        System.out.println(Thread.currentThread().getId() + "\t invoked sendEmail()");
    }
}
public class ReenterLockDemo {


    public static void main(String[] args) {
        Phone phone = new Phone();

        // 两个线程操作资源列
        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "t1").start();

        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "t2").start();
    }
}

在这里，我们编写了一个资源类phone，拥有两个加了synchronized的同步方法，分别是sendSMS 和 sendEmail，我们在sendSMS方法中，调用sendEmail。最后在主线程同时开启了两个线程进行测试，最后得到的结果为：

t1	 invoked sendSMS()     t1线程在外层方法获取锁的时候
t1	 invoked sendEmail()   t1在进入内层方法会自动获取锁
t2	 invoked sendSMS()     t2线程在外层方法获取锁的时候
t2	 invoked sendEmail()   t2在进入内层方法会自动获取锁

这就说明当 t1 线程进入sendSMS的时候，拥有了一把锁，同时t2线程无法进入，直到t1线程拿着锁，执行了sendEmail 方法后，才释放锁，这样t2才能够进入

证明ReentrantLock
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 资源类
 */
class Phone implements Runnable{

    Lock lock = new ReentrantLock();

    /**
     * set进去的时候，就加锁，调用set方法的时候，能否访问另外一个加锁的set方法
     */
    public void getLock() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t get Lock");
            setLock();
        } finally {
            lock.unlock();
        }
    }

    public void setLock() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t set Lock");
        } finally {
            lock.unlock();
        }
    }

    @Override
    public void run() {
        getLock();
    }
}
public class ReenterLockDemo {


    public static void main(String[] args) {
        Phone phone = new Phone();

        /**
         * 因为Phone实现了Runnable接口
         */
        Thread t3 = new Thread(phone, "t3");
        Thread t4 = new Thread(phone, "t4");
        t3.start();
        t4.start();
    }
}

现在我们使用ReentrantLock进行验证，首先资源类实现了Runnable接口，重写Run方法，里面调用get方法，get方法在进入的时候，就加了锁

    public void getLock() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t get Lock");
            setLock();
        } finally {
            lock.unlock();
        }
    }

然后在方法里面，又调用另外一个加了锁的setLock方法

    public void setLock() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t set Lock");
        } finally {
            lock.unlock();
        }
    }

最后输出结果我们能发现，结果和加synchronized方法是一致的，都是在外层的方法获取锁之后，线程能够直接进入里层

t3	 get Lock
t3	 set Lock
t4	 get Lock
t4	 set Lock

当我们在getLock方法加两把锁会是什么情况呢？ (阿里面试)

    public void getLock() {
        lock.lock();
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t get Lock");
            setLock();
        } finally {
            lock.unlock();
            lock.unlock();
        }
    }

最后得到的结果也是一样的，因为里面不管有几把锁，其它他们都是同一把锁，也就是说用同一个钥匙都能够打开

当我们在getLock方法加两把锁，但是只解一把锁会出现什么情况呢？

public void getLock() {
    lock.lock();
    lock.lock();
    try {
        System.out.println(Thread.currentThread().getName() + "\t get Lock");
        setLock();
    } finally {
        // lock.unlock();
        lock.unlock();
    }
}

得到结果

t3	 get Lock
t3	 set Lock

也就是说程序直接卡死，线程不能出来，也就说明我们申请几把锁，最后需要解除几把锁

当我们只加一把锁，但是用两把锁来解锁的时候，又会出现什么情况呢？

    public void getLock() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t get Lock");
            setLock();
        } finally {
            lock.unlock();
            lock.unlock();
        }
    }

这个时候，运行程序会直接报错

t3	 get Lock
t3	 set Lock
t4	 get Lock
t4	 set Lock
Exception in thread "t3" Exception in thread "t4" java.lang.IllegalMonitorStateException
	at java.util.concurrent.locks.ReentrantLock$Sync.tryRelease(ReentrantLock.java:151)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.release(AbstractQueuedSynchronizer.java:1261)
	at java.util.concurrent.locks.ReentrantLock.unlock(ReentrantLock.java:457)
	at com.moxi.interview.study.thread.Phone.getLock(ReenterLockDemo.java:52)
	at com.moxi.interview.study.thread.Phone.run(ReenterLockDemo.java:67)
	at java.lang.Thread.run(Thread.java:745)
java.lang.IllegalMonitorStateException
	at java.util.concurrent.locks.ReentrantLock$Sync.tryRelease(ReentrantLock.java:151)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.release(AbstractQueuedSynchronizer.java:1261)
	at java.util.concurrent.locks.ReentrantLock.unlock(ReentrantLock.java:457)
	at com.moxi.interview.study.thread.Phone.getLock(ReenterLockDemo.java:52)
	at com.moxi.interview.study.thread.Phone.run(ReenterLockDemo.java:67)
	at java.lang.Thread.run(Thread.java:745)

5、自旋锁

5.1、概括

自旋锁：spinlock，是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU

原来提到的比较并交换，底层使用的就是自旋，自旋就是多次尝试，多次访问，不会阻塞的状态就是自旋。

5.2、优缺点

优点：循环比较获取锁，直到成功为止，没有阻塞过程

缺点：当不断的自旋线程变多时，会消耗的CPU资源变多，还可能产生线程饥饿问题

5.3、手写一个自旋锁
public class ziXuan {

    AtomicReference<Thread> atomicReference = new AtomicReference<Thread>();

    /**
     * 加锁
     */
    public void myLock(){
        Thread thread = Thread.currentThread();

        System.out.println(Thread.currentThread().getName() + "\t come in ");

        while (!atomicReference.compareAndSet(null, thread)) {

        }
    }

    /**
     * 解锁
     */
    public void myUnLock(){
        // 获取当前进来的线程
        Thread thread = Thread.currentThread();

        // 自己用完了后，把atomicReference变成null
        atomicReference.compareAndSet(thread, null);

        System.out.println(Thread.currentThread().getName() + "\t invoked myUnlock()");
    }


    public static void main(String[] args) {

        ziXuan ziXuan = new ziXuan();

        new Thread(() -> {
            // 占有锁
            ziXuan.myLock();

            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            ziXuan.myUnLock();

        }, "AA").start();

        // 睡一秒，保证AA先执行
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {

            // 开始占有锁
            ziXuan.myLock();
            // 开始释放锁
            ziXuan.myUnLock();
        }, "BB").start();

    }
}

输出结果

AA	 come in 
BB	 come in 
AA	 invoked myUnlock()
BB	 invoked myUnlock()

首先输出的是 t1 come in

然后1秒后，tt线程启动，发现锁被t1占有，所有不断的执行 compareAndSet方法，来进行比较，直到t1释放锁后，也就是5秒后，t2成功获取到锁，然后释放

6、 独占锁（写锁） / 共享锁（读锁） / 互斥锁

6.1、概念

独占锁：指该锁一次只能被一个线程所拥有，对ReentrantLock和Synchronized而言都是独占锁

共享锁：指该锁可以被多个线程锁持有

对ReentrantReadWriteLock其读锁是共享，其写锁是独占

写的时候只能一个人写，但是读的时候，可以多个人同时读

6.2、为什么会有写锁和读锁

原来我们使用ReentrantLock创建锁的时候，是独占锁，也就是说一次只能一个线程访问，但是有一个读写分离场景，读的时候想同时进行，因此原来独占锁的并发性就没这么好了，因为读锁并不会造成数据不一致的问题，因此可以多个人共享读

多个线程 同时读一个资源类没有任何问题，所以为了满足并发量，读取共享资源应该可以同时进行，但是如果一个线程想去写共享资源，就不应该再有其它线程可以对该资源进行读或写

6.3、代码实现

实现一个读写缓存的操作，假设开始没有加锁的时候，会出现什么情况

class CaChe {
    private volatile Map<String, Object> map = new HashMap<>();

    // 添加数据
    public void put(String key, Object value) {
        System.out.println(Thread.currentThread().getName() + "\t 正在写入：" + key);
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        map.put(key, value);
        System.out.println(Thread.currentThread().getName() + "\t 写入完成");
    }
	// 获取数据
    public void get(String key) {
        System.out.println(Thread.currentThread().getName() + "\t 正在读取:");
        try {
            // 模拟网络拥堵，延迟0.3秒
            TimeUnit.MILLISECONDS.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Object value = map.get(key);
        System.out.println(Thread.currentThread().getName() + "\t 读取完成：" + value);
    }
}

运行

public static void main(String[] args) {
        CaChe caChe = new CaChe();
    // 创建五个线程，用于存数据
        for (int i = 1; i <= 5; i++) {
            int finalI = i;
            new Thread(() -> {
                caChe.put(finalI + "", finalI);
            }, String.valueOf(i)).start();
        }
    // 取数据
        for (int i = 1; i <= 5; i++) {
            int finalI = i;
            new Thread(() -> {
                caChe.get(finalI + "");
            }, String.valueOf(i)).start();
        }
    }

结果：我们可以看到，在写入的时候，写操作都没其它线程打断了，这就造成了，还没写完，其它线程又开始写，这样就造成数据不一致

1	 正在写入：1
5	 正在写入：5
4	 正在写入：4
3	 正在写入：3
2	 正在写入：2
1	 正在读取:
2	 正在读取:
3	 正在读取:
4	 正在读取:
5	 正在读取:
2	 读取完成：null
4	 读取完成：null
1	 读取完成：null
3	 读取完成：null
5	 读取完成：null
3	 写入完成
1	 写入完成
2	 写入完成
5	 写入完成
4	 写入完成

解决办法

上面的代码是没有加锁的，这样就会造成线程在进行写入操作的时候，被其它线程频繁打断，从而不具备原子性，这个时候，我们就需要用到读写锁来解决了

/**
* 创建一个读写锁
* 它是一个读写融为一体的锁，在使用的时候，需要转换
*/
private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();

当我们在进行写操作的时候，就需要转换成写锁

// 创建一个写锁
rwLock.writeLock().lock();

// 写锁 释放
rwLock.writeLock().unlock();

当们在进行读操作的时候，在转换成读锁

// 创建一个读锁
rwLock.readLock().lock();

// 读锁 释放
rwLock.readLock().unlock();

这里的读锁和写锁的区别在于，写锁一次只能一个线程进入，执行写操作，而读锁是多个线程能够同时进入，进行读取的操作

完整代码

class CaChe {
    private volatile Map<String, Object> map = new HashMap<>();

    ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public void put(String key, Object value) {

        // 上锁
        lock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t 正在写入：" + key);
            TimeUnit.SECONDS.sleep(1);
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + "\t 写入完成");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.writeLock().unlock();
        }

    }

    public void get(String key) {

        // 加读锁
        lock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t 正在读取:");
            // 模拟网络拥堵，延迟0.3秒
            TimeUnit.MILLISECONDS.sleep(300);
            Object value = map.get(key);
            System.out.println(Thread.currentThread().getName() + "\t 读取完成：" + value);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.readLock().unlock();
        }
    }
}

运行main方法同上

1	 正在写入：1
1	 写入完成
3	 正在写入：3
3	 写入完成
2	 正在写入：2
2	 写入完成
4	 正在写入：4
4	 写入完成
5	 正在写入：5
5	 写入完成
1	 正在读取:
5	 正在读取:
3	 正在读取:
4	 正在读取:
2	 正在读取:
2	 读取完成：2
3	 读取完成：3
5	 读取完成：5
4	 读取完成：4
1	 读取完成：1

从运行结果我们可以看出，写入操作是一个一个线程进行执行的，并且中间不会被打断，而读操作的时候，是同时5个线程进入，然后并发读取操作

7、Synchronized和Lock的区别

  1. synchronized是关键词属于JVM层面，Lock是一个类
  2. synchronized不需要手动去释放锁，执行完后系统会自动让线程释放对锁的占用。ReentrantLock则需要用户手动去释放锁，若没有手动去释放锁，就可能出现死锁的情况
  3. synchronized不可中断，除非抛出异常或正常运行退出。ReentrantLock可中断（1、设置超时时间 tryLock(Long timeout,TimeUnit unit) 2、LockInterruptibly()放代码块中，调用interrupt()方法可中断）
  4. synchronized是非公平锁，ReentrantLock可以设置公平锁和不公平锁
  5. synchronized 不可以绑定Condition，ReentrantLock可以绑定多个条件Condition，可以用来实现分组唤醒特定的线程，可精确唤醒，而不是像 synchronized随机唤醒一个线程或唤醒全部线程。

参考

本篇文章为学习笔记，并参考如下地址所做笔记，如有错误，还望指正

点击跳转

籍籍无名的白菜
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JUC 知识点
weixin_44311939的博客
06-28 308
写在前面 本文在学习JUC过程中，自己总结的一份JUC知识点，涵盖知识点，代码Demo 源码 GITHUB 地址：源码地址 将会持续更新 如果有什么地方总结的不完善或出现错误，欢迎留言补充和改正，共同进步！ JUC目录写在前面JUC 基础1. 什么是线程和进程？举例说明2. 线程的状态有哪些？3. wait 和 sleep 的区别？4. 什么是并发，什么是并行？5. JUC 常见异常JUC Lock接口1. Lock 和 Synchronized 区别在哪？2. 经典买票问题JUC 线程间通信1. .
【Java之多线程】JUC常见知识点全面总结_juc 考点
2401_84618023的博客
04-26 696
大部分情况下使用就足够了锁竞争激烈的时候，使用, 搭配trylock方法可以更灵活地控制加锁的行为，而不是死等。如果需要使用公平锁, 使用信号量Semaphore一般用来表示可用资源的个数，相当于一个计数器，可类比生活中停车场牌子上面显示的停车场剩余车位数量。当有车开进去的时候, 就相当于申请一个可用资源，可用车位就 -1 (这个称为信号量的 P 操作)当有车开出来的时候, 就相当于释放一个可用资源, 可用车位就 +1 (这个称为信号量的 V 操作)
JUC知识点总结
Novice_guy的博客
03-26 351
JUC juc->java.util.concurrent:并发编程中的工具类 三个包：concurrent，atomic，locks 进程和线程 进程：后台运行的一个程序，是操作系统分配资源的基本单位 线程：进程内部使用进程分配到的资源的，实现的某些功能，就是线程。 并发和并行 并发：而并发是指两个或多个事件在同一时间间隔发生。 并行：并行是指两个或者多个事件在同一时刻发生。 ...
JUC知识点汇总
weixin_42610002的博客
03-08 647
JUC汇总总结： 总结： 通常说的并发包即java.util.concurrent及其子包，集中了Java并发的各种基础工具类，具体： 提供了比Synchronized更高级的各种同步结构：CountDownLatch、CyclicBarrier、Semaphore等，可实现更丰富的多线程操作，例如用Semaphore作为资源控制器，限制同时工作的线程数量。 JUC之各种同步结构(Semapho...
JUC知识点学习
weixin_43203363的博客
10-20 670
1. 什么是JUC? JUC就是java.util .concurrent工具包的简称。这是一个处理线程的工具包. 2. 并发和并行? 单核并发就是多个线程操作同一个资源.本质就是想让电脑效能更高.充分利用cpu资源. 并行就是多核执行多个任务. 3. 线程和进程 进程中至少包含一个线程.进程是程序的一次执行过程 一个程序可以有多个进程. 进程有:初始态，执行态，等待状态，就绪状态，终止状态。 线程:线程是CPU调度和分派的基本单位它可与同属一个进程的其他的线程共享进程所拥有的全部资源。. 进程和线程的区别
JUC主要知识点整理
weixin_44898959的博客
03-20 370
Volatile与CAS Volatile是一个只能修饰成员变量的关键字。 对volatile变量进行写操作时，其生成的汇编代码会加上一个lock前缀，lock的作用是 将处理器缓存的数据写回内存 使其他处理器缓存了该内存地址的数据无效 Volatile的内存语义 JMM(java内存模型，逻辑概念) 我们来看一个例子，我们准备一个布尔类型的标记量flag,使用一个线程修改，两个线程获取这个flag； public class JMM { private boolean flag =fal.
JUC面试知识点总结1
08-08
1. 并行是指两个或者多个事件在同一时刻发生 2. 并行是在不同实体上的多个事件，并发是在同一实体上的多个事件 3. 在一台处理器上“同时”处理多个任务，在多台
AQS和JUC知识点讲解
最新发布
05-23
AQS和JUC知识点讲解
Java并发编程JUC知识点梳理总结
06-01
JUC并发编程知识点梳理思维导图
JUC知识点总结（三）ReentrantLock与ReentrantReadWriteLock源码解析
01-21
8. Lock接口 （ReentrantLock 可重入锁） 特性 ReentantLock 继承接口 Lock 并实现了接口中定义的方法， 它是一种可重入锁， 除了能完成 synchronized 所能完成的所有工作外，还提供了诸如可响应中断锁、可轮询锁...
JAVA-2020-核心知识点整理大全.zip
04-15
文档包含知识点较为全面，包括 java基础，集合，线程，jvm，spring，微服务，netty，各种分布式工具，设计模式，数据库，算法与数据结构，hadoop，spark等知识汇总，各部分内容表达简洁而不失重点，适合复习和检索...
常见的Java笔试题-JVM-JUC-Core:JUCJVM核心知识点
06-02
常见的Java笔试题 JUC、JMM核心知识点笔记 尚硅谷周阳老师课程——笔记。 / / JUC知识点 JMM volatile关键字 可见性 原子性 有序性 哪些地方用到过volatile？ 单例模式的安全问题 CAS CAS底层原理 CAS缺点 ABA问题 AtomicReference AtomicStampedReference和ABA问题的解决 集合类不安全问题 List CopyOnWriteArrayList Set HashSet和HashMap Map Java锁 公平锁/非公平锁 可重入锁/递归锁 锁的配对 自旋锁 读写锁/独占/共享锁 Synchronized和Lock的区别 CountDownLatch/CyclicBarrier/Semaphore CountDownLatch 枚举类的使用 CyclicBarrier Semaphore 阻塞队列 SynchronousQueue Callable接口 阻塞队列的应用——生产者消费者 传统模式 阻塞队列模式 阻塞队列的应用——线程池 线程池基本概念 线程池三种常用创建方式 线程池创建的七个参数 线程池底层原理
JUC知识点学习（1）
jifen_black的博客
08-01 135
JUC是啥？额，那个是并发包。啥是并发包？额，那个你打开这个网址：www.baidu.com输入并发包。我也搞不清楚这玩意咋学，但面试就他妈的要问，问到怀疑人生。然后在一个视屏中听到阳哥的声音，学习了下。但是没得资料，只好找到破旧不堪的图，自己整理。就有了这个，先来一点下下饭。当然这里都是进阶版，不属于基础概念那种。 一 谈谈对volatile的理解 volatile是java虚拟接提供的轻量级的...
【JUC】——JUC相关知识点，不断更新
我爱吃土豆
08-14 5500
前言 作为并发的基础，我们需要熟悉掌握JUC相关的知识，才能更好的在实际项目中运用 在 Java 5.0 提供了java.util.concurrent(简称JUC)包,在此包中增加了在并发编程中很常用的工具类, 用于定义类似于线程的自定义子系统,包括线程池,异步 IO 和轻量级任务框架;还提供了设计用于多线程上下文中 的 Collection 实现等; 以下为他人总结的JUC下常用类：...
juc详细知识
opprash
09-18 517
转自：http://blog.sina.com.cn/s/blog_777f59990102xofg.html JUC是Java5.0开始提供的一组专门实现多线程并发处理的开发架构，利用juc开发架构可以有效的解决实际线程项目开发之中出现的死锁、阻塞、资源访问与公平机制。 本课程将为读者完整的讲解java.util.concurrent开发包之中的各个核心组成类的使用、操作原理分析，并且通过具...
JUC知识点总结（一）JMM与volatile关键字
时光匆匆独白 的博客
03-18 315
JUC复习笔记（java.util.concurrent） 1. 并发的两个关键问题：线程间通信和线程间同步 线程通信机制有两种： 共享内存：隐式通信，显式同步； 消息传递：显式通信，隐式同步。（Java的并发采用的是共享内存模型。） 2. JAVA内存模型：JMM Java虚拟机规范试图定义一个Java内存模型(JMM)，以屏蔽所有类型的硬件和操作系统内存访问差异，让Java程序在不...
JUC快速入门各个知识点汇总
每个人都是独一无二的，把握好自己的节奏，跟着自己的心走。
04-07 1531
文章目录前言各类锁汇总相关锁知识点可重入锁与不可重入锁乐观锁与悲观锁自旋锁(含自定义自旋锁)知识补充上下文切换CPU多层缓存架构介绍CPU的三级缓存缓存一致性协议导致的问题一、初识JUC1.1、JUC是什么？1.2、JUC三个包介绍java.util.concurrent包java.util.concurrent.locks包(含两个模板)java.util.concurrent.atomic包1.3、synchronized与lock区别二、生产者消费者问题2.1、synchronized实现2.2、Lo
JUC知识点总结（八）线程池面试知识点总结
时光匆匆独白 的博客
03-25 231
15. 线程池 15.1 为什么要使用线程池？ 降低资源消耗：通过重复利用已创建的线程降低线程创建和销毁造成的消耗 提高响应速度：任务到达时，任务可以不需要等到线程创建就能立即执行 提高线程的可管理性 15.2 线程池的体系结构： java.util.concurrent.Executor : 负责线程的使用与调度的根接口 ExecutorService 子接口: 线程池的主要接...
阻塞队列（BlockingQueue）图解，以及实现类的简述
qq_40823802的博客
08-03 996
阻塞队列：顾名思义，首先他是一个队列，而一个阻塞队列在数据结构中所起的作用大致如图所示 相当于“生产者和消费者问题”。 当阻塞队列是空时：从队列中获取元素的操作将会被阻塞。 当阻塞队列是满时：往队列里添加元素的操作将会被阻塞。 试图从空的阻塞队列中获取元素的线程将会被阻塞，直到其他线程往空队列插入新的元素。同样， 试图往已满的阻塞队列添加新元素的线程同样也会被阻塞，直到其他的线程从列中移除一个或多...
java JUC的知识点
09-13
以下是Java JUC的一些重要知识点： 1. Lock接口和ReentrantLock类：提供了一种比Java中的synchronized关键字更灵活、可定制化的同步机制。 2. Condition接口：可以和Lock接口一起使用，提供了一种等待通知机制，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值