JUC并发编程详解锁与队列

Posted 2022-06-08 小王Java

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JUC并发编程详解锁与队列相关的知识，希望对你有一定的参考价值。

【JUC并发编程】

一、锁的定义

☁️锁机制

所谓的锁，可以理解为内存中的一个整型数，拥有两种状态：空闲状态和上锁状态。

通过锁机制，能够保证在多核多线程环境中，在某一个时间点上，只能有一个线程进入临界区代码，从而保证临界区中操作数据的一致性。所谓的锁，可以理解为内存中的一个整型数，拥有两种状态：空闲状态和上锁状态。加锁时，判断锁是否空闲，如果空闲，修改为上锁状态，返回成功。如果已经上锁，则返回失败。解锁时，则把锁状态修改为空闲状态。

二、Lock锁与 Synchronized

传统的 Synchronized

加到代码块或声明方法中实现线程安全

但是会消耗性能

Lock锁

加锁与解锁Lock锁实现类 【JUC并发编程】 Lock实现类公平锁与非公平锁

ReentrantLock
// 默认是非公平锁，在构造的时候传入true就说公平锁
    
//Ctrl + Alt + T 光标放在方法上 调出快捷方式 try-catch

【JUC并发编程】

Synchronized 和 Lock的区别

两者默认都是非公平锁，这样可以提高性能
Synchronized 是内置的Java关键字, Lock是一个Java类
Synchronized无法判断获取锁的状态， Lock可以判断是否获取到了锁
Synchronized会自动释放锁，Lock不会自动释放，需要手动关闭锁，如果不释放，会造成死锁
Synchronized线程1（获得锁，阻塞）、线程2（等待，等待...）； Lock就不一定会等待下去；Lock会去尝试获取锁tryLock
Synchronized可重入锁，不可以中断，非公平；Lock可重入锁，可以去判断锁，可以自行设置公平与非公平锁，传入boolean来选择锁
Synchronized 适合锁少量的代码同步问题；Lock锁适合锁大量的同步代码

三、多线程下的引发的问题

⭐经典案例：生产者与消费者问题

生产者与消费者问题描述了两个线程进程 --- 所谓的生产者与消费者，在实际运行时会发生原子性（数据不一致）问题。生产者的作用是一直投递数据，而消费者的作用就是一直不停的消费数据。该问题的关键就是要保证当生产者生产完毕产品后，若消费者没有消费产品，那么则停止生产，等待消费者消费完毕后继续生产产品，若生产者未生产产品，消费者已经消费完毕了产品，那么消费者等待生产者生产产品，生产者生产完毕后，消费者进行消费。

JUC版的生产者与消费者问题

通过Lock 找到 Condition 【JUC并发编程】 传统和JUC版本JUC 实现生产者与消费者

package com.wanshi.productorcustomer;

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

/**
 * 线程之间的通信问题：生产者与消费者问题！等待唤醒，通知唤醒
 * 线程交替执行， Productor Customer   操作同一个变量，num = 0
 * C：num+1
 * P：num-1
 * */
public class Productor2 

    public static void main(String[] args) 
        Data2 data = new Data2();

        new Thread(() -> 
            for (int i = 0; i < 10; i++) 
                try 
                    data.increment();
                 catch (InterruptedException e) 
                    e.printStackTrace();
                
            
        , "A").start();

        new Thread(() -> 
            for (int i = 0; i < 10; i++) 
                try 
                    data.decrement();
                 catch (InterruptedException e) 
                    e.printStackTrace();
                
            
        , "B").start();

        new Thread(() -> 
            for (int i = 0; i < 10; i++) 
                try 
                    data.increment();
                 catch (InterruptedException e) 
                    e.printStackTrace();
                
            
        , "C").start();

        new Thread(() -> 
            for (int i = 0; i < 10; i++) 
                try 
                    data.decrement();
                 catch (InterruptedException e) 
                    e.printStackTrace();
                
            
        , "D").start();




    



//判断是否需要等待，业务，通知

//数字资源类
class Data2 

    private int num = 0;

    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();



    // +1 操作
    public void increment() throws InterruptedException 
        try 
            lock.lock();
            while (num != 0) 
                //等待
                condition.await();
            
            num ++;
            System.out.println(Thread.currentThread().getName() + " --- >" + num);
            //通知其它线程，+1完毕
            condition.signalAll();
         catch (Exception e) 

         finally 
            lock.unlock();
        
    

    //-1 操作
    public  void decrement() throws InterruptedException 
        try 
            lock.lock();
            while (num == 0) 
                //等待
                condition.await();
            
            num --;
            System.out.println(Thread.currentThread().getName() + " --- >" + num);
            //通知其它线程，-1完毕
            condition.signalAll();
         catch (Exception e) 

         finally 
            lock.unlock();

任何一个新的技术，绝对不是仅仅只是覆盖了原来的技术，有自己独特的优势和补充原来的技术

Condition

四、读写锁

读写锁的定义

读写锁是指两个锁，读锁和写锁。

为什么会存在读写锁呢？

因为synchronized粒度太大了，并不适合我们，可重入锁的粒度相较于读锁（共享锁）也较大，我们需要粒度小的锁。
大部分场景下，读不需要加锁，而写需要加锁，因为写入不加锁有可能出现写入覆盖和信息不一致的情况，并且大部分的读需求粒度更小的锁，这样会占用更少的资源。

独占锁（写锁) —次只能被一个线程占有共享锁（读锁) 多个线程可以同时占有ReadWriteLock 读写锁 【JUC并发编程】

package com.wanshi.rw;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 独占锁（写锁） 一次只能被一个线程占用
 * 共享锁（读锁）多个线程可以同时占用
 * 读写锁
 * ReadWriteLock
 * 读-读  可以共存
 * 读-写  不能共存
 * 写-写  不能共存
 */
public class ReadWriteLockDemo 

    public static void main(String[] args) 
        MyCache myCache = new MyCache();

        //写入
        for (int i = 1; i <= 5; i++) 
            final int type = i;
            new Thread(() -> 
                myCache.put(type+"", type);
            , String.valueOf(i)).start();
        
        for (int i = 1; i <= 5; i++) 
            final int type = i;
            new Thread(() -> 
                myCache.get(type + "");
            , String.valueOf(i)).start();
        
    


/**
 * 自定义缓存
 */
class MyCache 
    private volatile Map<String, Object> map = new HashMap<>();

    //读写锁：更加细粒度的控制
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    //存，写，只希望又一个线程写
    public void put(String key, Object val) 
        readWriteLock.writeLock().lock();
        try 
            System.out.println(Thread.currentThread().getName() + "写入" + key);
            map.put(key, val);
            System.out.println(Thread.currentThread().getName() + "写入OK");
         catch (Exception e) 
            e.printStackTrace();
         finally 
            readWriteLock.writeLock().unlock();
        
    

    //取，读，多个线程可以读
    public void get(String key) 
        readWriteLock.readLock().lock();
        try 
            System.out.println(Thread.currentThread().getName() + "读取");
            System.out.println(map.get(key));
            System.out.println(Thread.currentThread().getName() + "读取OK");
         catch (Exception e) 
            e.printStackTrace();
         finally 
            readWriteLock.readLock().unlock();

运行效果 【JUC并发编程】

五、常用的辅助类（必会）

☀️CountDownLatch

【JUC并发编程】

package com.wanshi.add;

import java.util.concurrent.CountDownLatch;

//计数器
public class CountDownLatchDemo 

    public static void main(String[] args) throws InterruptedException 
        //总数是6，必须要执行任务的时候，再使用！
        CountDownLatch countDownLatch = new CountDownLatch(6);

        for (int i = 1; i <= 6; i++) 
            new Thread(() -> 
                System.out.println(Thread.currentThread().getName() + " Go out");
                //数量-1
                countDownLatch.countDown();
            , String.valueOf(i)).start();
        

        //等待计数器归0 然后再向下执行
        countDownLatch.await();

        System.out.println("Close Door");

原理： countDownLatch.countDown(); 数量-1

countDownLatch.await(); 等待计数器归0，然后再往下执行

每次有线程调用 countDown() 就会数量-1，假设计数器变为0，await方法就会被唤醒，继续执行

⛅CycliBarrier

【JUC并发编程】

package com.wanshi.add;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CycliBarrierDemo 

    public static void main(String[] args) 
        // 集齐7颗龙珠召唤神龙
        //召唤龙珠线程
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7, ()->
            System.out.println("召唤神龙成功！");
        );
        for (int i = 1; i <= 7; i++) 
            final int temp = i;
            new Thread(() -> 
                System.out.println(Thread.currentThread().getName() + "收集" + temp + "颗龙珠");
                try 
                    //等待7个线程执行完毕
                    cyclicBarrier.await();
                    System.out.println("abc");
                 catch (InterruptedException e) 
                    e.printStackTrace();
                 catch (BrokenBarrierException e) 
                    e.printStackTrace();
                
            ).start();

⛄Semaphore

Semaphore：信号量

【JUC并发编程】 抢车位！

6个车 -- 3个停车位

package com.wanshi.add;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class SemaphoreDemo 

    public static void main(String[] args) 
        //限流
        Semaphore semaphore = new Semaphore(3);
        for (int i = 1; i <= 6; i++) 
            new Thread(() -> 
                //acquire() 得到
                try 
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "抢到车位");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName() + "离开车位");
                 catch (InterruptedException e) 
                    e.printStackTrace();
                 finally 
                    semaphore.release();
                
                //release() 释放
            , String.valueOf(i)).start();

semaphore.acquire(); 获得，如果已经满了就等待被释放为止！

semaphore.release(); 释放，会将当前的信号量释放 + 1，然后唤醒等待的线程！

作用：多个共享资源互斥的使用，并发限流，控制最大的线程数

六、其它常用锁

⌛公平锁、非公平锁

公平锁：非常公平，不可以插队，必须先来先到非公平锁：非常不公平，可以插队（默认都是非公平锁，目的是为了保证效率）

//Lock 锁实现类，默认非公平锁
public ReentrantLock() 
    sync = new NonfairSync();


//传入true代表改变为公平锁
public ReentrantLock(boolean fair) 
    sync = fair ? new FairSync() : new NonfairSync();

⚡可重入锁

可重入锁又叫递归锁，指的是可重复可递归调用的锁，在外层使用锁之后，在内层仍然可以获得锁使用并且不发生死锁，这样的锁就叫做可重入锁。简单的来说就是：在一个synchronized修饰的方法或代码块的内部调用本类的其他synchronized修饰的方法或代码块时，是永远可以得到的。

Java中 ReentrantLock 和 synchronized 都是可重入锁，可重入锁能一定程度避免死锁。 【JUC并发编程】

Synchronized版本可重入锁

package com.wanshi.lock;


//Synchronized版本
public class Demo01 

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

        new Thread(() -> 
            phone.sms();
        , "A").start();

        new Thread(() -> 
            phone.sms();
        , "B").start();
    


class Phone 

    public synchronized void sms() 
        System.out.println(Thread.currentThread().getName() + " ---> 发信息...");
        call();
    

    public synchronized void call() 
        System.out.println(Thread.currentThread().getName() + " ---> 打电话....");

Lock版本可重入锁

package com.wanshi.lock;

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

public class Demo02  

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

        new Thread(() -> 
            phone.sms();
        , "A").start();

        new Thread(() -> 
            phone.sms();
        , "B").start();
    


class Phone2 

    Lock lock = new ReentrantLock();

    //注意：Lock锁必须成对出现，如果不是成对出现的，会出现死锁现象
    public void sms() 
        lock.lock();
        try 
            System.out.println(Thread.currentThread().getName() + " ---> 发信息...");
            call();
         catch (Exception e) 
            e.printStackTrace();
         finally 
            lock.unlock();
        
    

    public void call() 
        lock.lock();
        try 
            System.out.println(Thread.currentThread().getName() + " ---> 打电话....");
         catch (Exception e) 
            e.printStackTrace();
         finally 
            lock.unlock();

➿自旋锁

自旋锁： spinLock,指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，当线程发现锁被占用时，会不断循环判断锁的状态，直到获取。这样的好处是减少线程上下文切换的开销，缺点是循环会消耗CPU资源。

自旋锁 【JUC并发编程】 自己实现自旋锁

package com.wanshi.lock;

import java.util.concurrent.atomic.AtomicReference;

public class SpinlockDemo 

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

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

        System.out.println(Thread.currentThread().getName() + " ---> myLock");

        //期待更新的转换为线程    A线程进来后直接退出了，B线程进来后自旋，等待A线程结束后B线程结束自旋。
        while (!atomicReference.compareAndSet(null, thread)) 

        

    

    //解锁
    public void myUnLock() 
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName() + " ---> myUnLock");

        atomicReference.compareAndSet(thread, null);

测试自旋锁

package com.wanshi.lock;

import java.util.concurrent.TimeUnit;

public class Test 

    public static void main(String[] args) throws InterruptedException 
        SpinlockDemo lock = new SpinlockDemo();

        new Thread(() -> 
            lock.myLock();
            try 
                TimeUnit.SECONDS.sleep(2);
             catch (InterruptedException e) 
                e.printStackTrace();
             finally 
                lock.myUnLock();
            
        , "A").start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(() -> 
            lock.myLock();
            try 
                TimeUnit.SECONDS.sleep(1);
             catch (InterruptedException e) 
                e.printStackTrace();
             finally 
                lock.myUnLock();
            
        , "B").start();

【JUC并发编程】

✂️死锁

死锁：两个线程持有自己的资源尝试去获取其它线程的资源，其它线程未释放，导致阻塞，最终形成僵持，造成死锁

产生死锁的原因主要包括：

系统资源不足
程序执行的顺序有问题
资源分配不当等

【JUC并发编程】 怎么排除死锁：

互斥条件：一个线程每次只能被一个进程调用
不可剥夺条件：进程所获得的资源在未使用完毕之前，不被其他进程强行剥夺，而只能由获得该资源的进程资源
以上是关于JUC并发编程详解锁与队列的主要内容，如果未能解决你的问题，请参考以下文章

JUC并发编程线程池及相关面试题详解

JUC并发编程--- 阻塞队列和同步队列使用

java并发编程的艺术——第五章总结（Lock锁与队列同步器）

并发编程实践之公平有界阻塞队列实现

java并发编程工具类JUC第六篇:SynchronousQueue同步队列

Java并发编程- J.U.C之AQS及其相关组件详解

JUC并发编程 详解锁与队列

一、锁的定义

☁️锁机制

二、Lock锁 与 Synchronized

三、多线程下的引发的问题

⭐经典案例：生产者与消费者问题

四、读写锁

五、常用的辅助类（必会）

☀️CountDownLatch

⛅CycliBarrier

⛄Semaphore

六、其它常用锁

⌛公平锁、非公平锁

⚡可重入锁

➿自旋锁

✂️死锁

JUC并发编程详解锁与队列

二、Lock锁与 Synchronized