当前位置：首页 > news >正文

三、Java中七大常用锁实战

news 来源：原创 2025/5/3 16:28:37

1、锁的7大分类

2.Lock接口的常见方法有哪些？

解释：

1.lock() - 加锁

2.lockInterruptibly() - 实现可中断的锁

3.tryLock() - 尝试获取锁，只会尝试一次

4.unlock() - 解锁

5.newCondition() -

方法示例：

void lock() -

package imooc4.lock;

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

/**
 * @Description: 测试lock接口
 */
public class TestLock {
    static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        Lock lock = new ReentrantLock();
        //模拟多个线程执行++操作 结果1000
        List<Thread> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(() -> {
                for (int j = 0; j < 100; j++) {
                    lock.lock();
                    try {
                        count++;
                    } finally {
                        lock.unlock();
                    }
                }
            });
            list.add(thread);
        }
        for (Thread thread : list) {
            thread.start();
        }
        for (Thread thread : list) {
            thread.join();
        }
        System.out.println(count);//如果是1000结果就是正确的
    }
}

运行结果：


boolean tryLock() -

package imooc4.lock;

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

/**
 * @Description:
 * Lock lock = ...;
 *      * if (lock.tryLock()) {
 *      *   try {
 *      *     // manipulate protected state
 *      *   } finally {
 *      *     lock.unlock();
 *      *   }
 *      * } else {
 *      *   // perform alternative actions
 *      * }}</pre>
 */
public class TestTryLock {
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                if(lock.tryLock()){
                    try {
                        System.out.println("拿到了锁");
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    } finally {
                        lock.unlock();
                    }
                }else{
                    System.out.println("没拿到锁");
                }
            }).start();
        }
    }
}

运行结果：


boolean tryLock(long time, TimeUnit unit) -

package imooc4.lock;

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

/**
 * @Description:
 */
public class TestTryLockWithTimeOut {
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        Thread thread = new Thread(() -> {
            try {
                if (lock.tryLock(1, TimeUnit.SECONDS)) {
                    System.out.println(Thread.currentThread().getName() + " 拿到了锁");
                } else {
                    System.out.println(Thread.currentThread().getName() + " 没拿到锁");
                    return;
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            try {
                //临界资源的操作
                System.out.println(Thread.currentThread().getName() + " 正在操作临界资源");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                lock.unlock();
            }
        });

        Thread thread1 = new Thread(() -> {
            try {
                if (lock.tryLock(1, TimeUnit.SECONDS)) {
                    System.out.println(Thread.currentThread().getName() + " 拿到了锁");
                } else {
                    System.out.println(Thread.currentThread().getName() + " 没拿到锁");
                    return;
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            try {
                //临界资源的操作
                System.out.println(Thread.currentThread().getName() + " 正在操作临界资源");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                lock.unlock();
            }
        });
        thread.start();
        thread1.start();
    }
}

运行结果：

3.Lock锁如何实现生产者消费者模式-Condition接口？

之前实现的场景

之前是通过锁对象的wait()和notifyAll()实现的吃自助餐的场景

现在通过Lock和Condition实现

、如果只有一个Condtion,那它的和Synchronized的实现机制是一样的，如果创建多个Condtion，会让等待唤醒机制更加灵活。

package imooc4.condition;

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

/**
 * @Description:
 */
public class Desk {
    //标注桌子上是否有食物
    public static boolean flag = false;
    public static final Lock lock = new ReentrantLock();
    //给consumer用的condition
    public static Condition condition4Consumer =  lock.newCondition();
    //给producer用的condition
    public static Condition condition4Producer =  lock.newCondition();
}

package imooc4.condition;

/**
 * @Description:
 */
public class Consumer extends Thread{
    @Override
    public void run() {
        while (true){
            //不断地拿食物
            Desk.lock.lock();
            try {
                if(Desk.flag){
                    //如果有实物 拿走，并通知厨师
                    System.out.println("顾客取走食物");
                    Desk.flag = false;
                    System.out.println("consumer 准备唤醒producer");
                    Desk.condition4Producer.signalAll();
                }else{
                    try {
                        Desk.condition4Consumer.await();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }finally {
                Desk.lock.unlock();
            }
        }
    }
}

package imooc4.condition;

/**
 * @Description:
 */
public class Producer extends Thread{
    @Override
    public void run() {
        while (true){
            Desk.lock.lock();
            try {
                if(Desk.flag){
                    //厨师等待
                    try {
                        Desk.condition4Producer.await();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }else{
                    //厨师开始工作
                    System.out.println("厨师正在补充食物");
                    Desk.flag = true;
                    System.out.println("producer 准备唤醒consumer");
                    Desk.condition4Consumer.signalAll();
                }
            }finally {
                Desk.lock.unlock();
            }
        }
    }
}

package imooc4.condition;

/**
 * @Description:
 */
public class TestConsumerAndProducer {
    public static void main(String[] args) {
        Producer producer = new Producer();
        Producer producer1 = new Producer();
        Producer producer2 = new Producer();
        Producer producer3= new Producer();
        Consumer consumer = new Consumer();
        Consumer consumer1 = new Consumer();
        Consumer consumer2 = new Consumer();
        Consumer consumer3 = new Consumer();
        producer.start();
        producer1.start();
        producer2.start();
        producer3.start();
        consumer.start();
        consumer1.start();
        consumer2.start();
        consumer3.start();
    }
}

运行结果：

4.选用锁时该用synchronized关键是还是Lock接口？

5.公平锁与非公平锁应该选用哪个？

公平锁 -

package imooc4.fair;

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

/**
 * @Description: 测试公平锁
 */
public class TestFairLock {
    //公平锁
    static Lock lock = new ReentrantLock(true);
    public static void main(String[] args) {
        //创建多个线程，每个线程多次加锁，
        // 拿到锁后检查时哪个线程拿到的锁
        for (int i = 0; i < 3; i++) {
            new Thread(()->{
                for (int j = 0; j < 2; j++) {
                    //加锁
                    lock.lock();
                    try {
                        System.out.println("当前获取锁的线程"+
                                Thread.currentThread().getName());
                    }finally {
                        lock.unlock();
                    }
                }
            }).start();
        }
    }
}

运行结果：

非公平锁 -

package imooc4.fair;

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

/**
 * @Description:
 */
public class TestUnfairLock {
    //非公平锁
    static Lock lock = new ReentrantLock(false);
    public static void main(String[] args) {
        //创建多个线程，每个线程多次加锁，
        // 拿到锁后检查时哪个线程拿到的锁
        for (int i = 0; i < 3; i++) {
            new Thread(()->{
                for (int j = 0; j < 2; j++) {
                    //加锁
                    lock.lock();
                    try {
                        System.out.println("当前获取锁的线程"+
                                Thread.currentThread().getName());
                    }finally {
                        lock.unlock();
                    }
                }
            }).start();
        }
        //A B C
        //A-1 A-2
        //B-1 B-2
        //C-1 C-2
    }
}

运行结果：

6.（可中断和不可中断）如何使用Lock接口实现可中断锁？

代码示例：

package imooc4.interrupt;

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

/**
 * @Description: 测试可中断锁
 */
public class TestInterruptLock {
    static final Lock lock = new ReentrantLock();
    public static void main(String[] args) throws InterruptedException {
        //受害人转账线程 尝试获取可中断锁
        Thread thread = new Thread(() -> {
            try {
                lock.lockInterruptibly();
            } catch (InterruptedException e) {
                System.out.println("受害人转账操作取消，钱财找回，谢谢民警");
                return;
            }
            try {
                System.out.println("受害 人开始转账给骗子");
            } finally {
                lock.unlock();
            }
        });
        Thread thread1 = new Thread(() -> {
            try {
                lock.lockInterruptibly();
            } catch (InterruptedException e) {
            }
            try {
                Thread.sleep(3000);
                System.out.println("其他的转账线程");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                lock.unlock();
            }
        });
        //其他转账线程执行
        thread1.start();
        Thread.sleep(100);
        //受害人转账线程执行
        thread.start();
        Thread.sleep(100);
        thread.interrupt();
    }
}

运行结果：

7.（共享锁独占锁）如何根据读操作和写操作拆分锁粒度-读写锁ReadWriteLock?

所以readLock、writeLock返回的是Lock的实现类。

package imooc4.lock;

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

/**
 * @Description:测试读读不互斥，读写互斥
 */
public class TestReentrantReadWriteLock {
    final static ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    final static Lock writeLock = readWriteLock.writeLock();
    final static Lock readLock = readWriteLock.readLock();

//    final static Lock lock = new ReentrantLock();
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            writeLock.lock();
            try {
                Thread.sleep(1000);
                System.out.println(System.currentTimeMillis());
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                writeLock.unlock();
            }
        });
        Thread thread1 = new Thread(() -> {
            writeLock.lock();
            try {
                Thread.sleep(1000);
                System.out.println("要进行写操作，需要与其他读操作互斥，也需要与其他写操作互斥");
                System.out.println(System.currentTimeMillis());
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                writeLock.unlock();
            }
        });
        thread.start();
        thread1.start();
    }
}

模拟电商场景：

package imooc4.lock.demo;

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @Description:
 */
public class Product {
    //商品名称
    private String name;
    //价格
    private double price;
    //赠送
    private double coupon;
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public String getName() {
        return name;
    }

    public double getPrice() {
        lock.readLock().lock();
        try {
            return price;
        }finally {
            lock.readLock().unlock();
        }
    }

    public double getCoupon() {
        lock.readLock().lock();
        try {
            return coupon;
        }finally {
            lock.readLock().unlock();
        }
    }
    public void updateProductInfo(double newPrice,double newCoupon){
        lock.writeLock().lock();
        try {
            this.price = newPrice;
            Thread.sleep(1000);
            this.coupon = newCoupon;
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            lock.writeLock().unlock();
        }
    }

    public Product(String name, double price, double coupon) {
        this.name = name;
        this.price = price;
        this.coupon = coupon;
    }

    @Override
    public String toString() {
        return "Product{" +
                "name='" + name + '\'' +
                ", price=" + price +
                ", Coupon=" + coupon +
                ", lock=" + lock +
                '}';
    }
}

package imooc4.lock.demo;

/**
 * @Description:
 */
public class TestProduct {
    public static void main(String[] args) throws InterruptedException {
        Product product = new Product("拉杆箱",200,150);
        System.out.println(product);
        Thread writeThread = new Thread(()->{
            product.updateProductInfo(150,100);
        });
        Thread readThread = new Thread(() -> {
            double price = product.getPrice();
            double coupon = product.getCoupon();
            System.out.println(price);
            System.out.println(coupon);
        });
        writeThread.start();
        Thread.sleep(500);
        readThread.start();
//        System.out.println(product);
    }
}

运行结果：

8.（读写锁）读写锁ReadWriteLock何时使用锁的降级？

大白话：

释放写锁，再获取读锁，与不释放写锁，先获取读锁，再释放写锁的区别？

释放写锁，再获取读锁 - 就是普通锁的获取与释放的过程，中间会产生时间间隔，锁可能被其他的写线程抢占；

不释放写锁，先获取读锁，再释放写锁 - 这把锁就不会被别的写线程抢占，锁的降级。

注意：

如果先读锁，再获取写锁 - 这里不是升级锁，而是先读锁解锁，再获取写锁。

代码案例：

package imooc4.lock.demo;

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @Description:
 */
public class Product {
    //商品名称
    private String name;
    //价格
    private double price;
    //赠送
    private double coupon;
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public String getName() {
        return name;
    }

    public double getPrice() {
        lock.readLock().lock();
        try {
            return price;
        }finally {
            lock.readLock().unlock();
        }
    }

    public double getCoupon() {
        lock.readLock().lock();
        try {
            return coupon;
        }finally {
            lock.readLock().unlock();
        }
    }
    public void updateProductInfo(double newPrice,double newCoupon){
        lock.writeLock().lock();
        try {
            this.price = newPrice;
            Thread.sleep(1000);
            this.coupon = newCoupon;
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            lock.writeLock().unlock();
        }
    }

    public Product(String name, double price, double coupon) {
        this.name = name;
        this.price = price;
        this.coupon = coupon;
    }

    @Override
    public String toString() {
        return "Product{" +
                "name='" + name + '\'' +
                ", price=" + price +
                ", Coupon=" + coupon +
                ", lock=" + lock +
                '}';
    }
}

package imooc4.lock.demo;

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.function.Supplier;

/**
 * @Author: Alfred
 * @ModuleOwner: Alfred
 * @Description:
 *
 *
 *
 * class CachedData {
 *   Object data;
 *   boolean cacheValid;
 *   final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
 *
 *   void processCachedData() {
 *     rwl.readLock().lock();
 *     if (!cacheValid) {
 *       // Must release read lock before acquiring write lock
 *       rwl.readLock().unlock();
 *       rwl.writeLock().lock();
 *       try {
 *         // Recheck state because another thread might have
 *         // acquired write lock and changed state before we did.
 *         if (!cacheValid) {
 *           data = ...;
 *           cacheValid = true;
 *         }
 *         // Downgrade by acquiring read lock before releasing write lock
 *         rwl.readLock().lock();
 *       } finally {
 *         rwl.writeLock().unlock(); // Unlock write, still hold read
 *       }
 *     }
 *
 *     try {
 *       use(data);
 *     } finally {
 *       rwl.readLock().unlock();
 *     }
 *   }
 * }}
 */
public class CachedData<T> {
    T data;
    boolean cacheValid;
    final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    public void setCacheValid(boolean cacheValid) {
        this.cacheValid = cacheValid;
    }

    /**
     * 查询缓存或者设置缓存
     * 如果缓存有效，则使用缓存
     */
    public T processCachedData(Supplier<T> supplier){
        readWriteLock.readLock().lock();
        //如果缓存有效就读
        //如果缓存失效，则写
        if(!cacheValid){
            //必须先解锁在加锁
            readWriteLock.readLock().unlock();
            readWriteLock.writeLock().lock();
            //更新缓存
            try {
                if(!cacheValid){
                    data = supplier.get();
                    cacheValid = true;
                }
                //锁降级开始
                //没有释放锁,这个锁会和其他写线程阻塞，为了保护 ---System.out.println(data);
                readWriteLock.readLock().lock();
            }finally {
                readWriteLock.writeLock().unlock();
            }
        }
        try {
            //使用缓存
            return data;
        }finally {
            readWriteLock.readLock().unlock();
        }


    }
}

package imooc4.lock.demo;

import org.junit.Test;

import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @Description: 商品上架，更新，下架业务
 */
public class ProductService {
    //商品信息缓存 productName -> CachedData
    Map<String,CachedData<Product>> map = new ConcurrentHashMap<>();
    Map<String,Product> mockDataBase = new HashMap<>();

    @Test
    public void TestCache(){
        CachedData<Product> cachedData = new CachedData<Product>();
        String productName = "trunk";
        Product product = cachedData.processCachedData(() -> new Product(productName, 200, 150));
        map.put(productName,cachedData);
        product.updateProductInfo(150,100);
        cachedData.setCacheValid(false);
        //从db查询数据
        Product product1 = cachedData.processCachedData(this::queryDataFromDb);
        System.out.println(product1);

    }

    @Test
    public void testProduct() throws InterruptedException {
        new Thread(this::saveProduct).start();
        Thread.sleep(50);
        final String productName = "trunk";
        //下单线程1
        new Thread(()->{
            Product product = queryProduct(productName);
            if(Objects.nonNull(product)){
                System.out.println("用户拿着这个"+product.getName()+"下单了，价格:"+product.getPrice()+
                        "赠送优惠券"+product.getCoupon());
            }
        }).start();
        Thread.sleep(50);
        //更新商品
        new Thread(()->updateProduct(productName)).start();
        Thread.sleep(50);
        //模拟并发写缓存
        //多个线程同时下单
        //下单线程2
        new Thread(()->{
            Product product = queryProduct(productName);
            if(Objects.nonNull(product)){
                System.out.println("用户拿着这个"+product.getName()+"下单了，价格:"+product.getPrice()+
                        "赠送优惠券"+product.getCoupon());
            }
        }).start();
        //下单线程3
        new Thread(()->{
            Product product = queryProduct(productName);
            if(Objects.nonNull(product)){
                System.out.println("用户拿着这个"+product.getName()+"下单了，价格:"+product.getPrice()+
                        "赠送优惠券"+product.getCoupon());
            }
        }).start();
        while (true){

        }
    }

    /**
     * 商品上架 （保存商品）
     * @return
     */
    public int saveProduct(){
        String productName = "trunk";
        Product product = new Product(productName,200,150);
        //保存数据到数据库
        mockDataBase.put(productName,product);
        return 1;
    }

    /**
     * 查询商品信息
     * @param productName
     * @return
     */
    public Product queryProduct(String productName){
        CachedData<Product> cacheData = getCacheData(productName);
        return cacheData.processCachedData(()->mockDataBase.get(productName));
    }

    private CachedData<Product> getCacheData(String productName) {
//        //操作1
//        CachedData<Product> cachedData = map.get(productName);
//        if(cachedData==null){
//            map.put(productName,new CachedData<>());
//        }
        //操作2
        return map.compute(productName, (k, v) -> {
            if (v == null) {
                return new CachedData<>();
            } else {
                return v;
            }
        });
    }

    /**
     * 更新商品
     * @param productName
     * @return
     */
    public int updateProduct(String productName){
        Product product = queryProduct(productName);
        if(Objects.isNull(product)){
            return 0;
        }
        product.updateProductInfo(150,100);
        mockDataBase.put(productName,product);
        CachedData<Product> cacheData = getCacheData(productName);
        cacheData.setCacheValid(false);
        map.put(productName,cacheData);
        return 1;
    }

    /**
     * 商品下架
     * @return
     */
    public int deleteProduct(String productName){
        //查询商品
        Product product = queryProduct(productName);
        if(Objects.isNull(product)){
            return 0;
        }
        mockDataBase.remove(productName);
        map.remove(productName);
        return 1;
    }

    private Product queryDataFromDb() {
        return new Product("trunk",150,100);
    }
}

、

package imooc4.lock.demo;

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @Description:
 */
public class Product {
    //商品名称
    private String name;
    //价格
    private double price;
    //赠送
    private double coupon;
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public String getName() {
        return name;
    }

    public double getPrice() {
        lock.readLock().lock();
        try {
            return price;
        }finally {
            lock.readLock().unlock();
        }
    }

    public double getCoupon() {
        lock.readLock().lock();
        try {
            return coupon;
        }finally {
            lock.readLock().unlock();
        }
    }
    public void updateProductInfo(double newPrice,double newCoupon){
        lock.writeLock().lock();
        try {
            this.price = newPrice;
            Thread.sleep(1000);
            this.coupon = newCoupon;
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            lock.writeLock().unlock();
        }
    }

    public Product(String name, double price, double coupon) {
        this.name = name;
        this.price = price;
        this.coupon = coupon;
    }

    @Override
    public String toString() {
        return "Product{" +
                "name='" + name + '\'' +
                ", price=" + price +
                ", Coupon=" + coupon +
                ", lock=" + lock +
                '}';
    }
}

package imooc4.lock.demo;

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.function.Supplier;

/**
 * @Author: Alfred
 * @ModuleOwner: Alfred
 * @Description:
 *
 *
 *
 * class CachedData {
 *   Object data;
 *   boolean cacheValid;
 *   final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
 *
 *   void processCachedData() {
 *     rwl.readLock().lock();
 *     if (!cacheValid) {
 *       // Must release read lock before acquiring write lock
 *       rwl.readLock().unlock();
 *       rwl.writeLock().lock();
 *       try {
 *         // Recheck state because another thread might have
 *         // acquired write lock and changed state before we did.
 *         if (!cacheValid) {
 *           data = ...;
 *           cacheValid = true;
 *         }
 *         // Downgrade by acquiring read lock before releasing write lock
 *         rwl.readLock().lock();
 *       } finally {
 *         rwl.writeLock().unlock(); // Unlock write, still hold read
 *       }
 *     }
 *
 *     try {
 *       use(data);
 *     } finally {
 *       rwl.readLock().unlock();
 *     }
 *   }
 * }}
 */
public class CachedData<T> {
    T data;
    boolean cacheValid;
    final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    public void setCacheValid(boolean cacheValid) {
        this.cacheValid = cacheValid;
    }

    /**
     * 查询缓存或者设置缓存
     * 如果缓存有效，则使用缓存
     */
    public T processCachedData(Supplier<T> supplier){
        readWriteLock.readLock().lock();
        //如果缓存有效就读
        //如果缓存失效，则写
        if(!cacheValid){
            //必须先解锁在加锁
            readWriteLock.readLock().unlock();
            readWriteLock.writeLock().lock();
            //更新缓存
            try {
                if(!cacheValid){
                    data = supplier.get();
                    cacheValid = true;
                }
                //锁降级开始
                //没有释放锁,这个锁会和其他写线程阻塞，为了保护 ---System.out.println(data);
                readWriteLock.readLock().lock();
            }finally {
                readWriteLock.writeLock().unlock();
            }
        }
        try {
            //使用缓存
            return data;
        }finally {
            readWriteLock.readLock().unlock();
        }


    }
}

package imooc4.lock.demo;

import org.junit.Test;

import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @Description: 商品上架，更新，下架业务
 */
public class ProductService {
    //商品信息缓存 productName -> CachedData
    Map<String,CachedData<Product>> map = new ConcurrentHashMap<>();
    Map<String,Product> mockDataBase = new HashMap<>();

    @Test
    public void TestCache(){
        CachedData<Product> cachedData = new CachedData<Product>();
        String productName = "trunk";
        Product product = cachedData.processCachedData(() -> new Product(productName, 200, 150));
        map.put(productName,cachedData);
        product.updateProductInfo(150,100);
        cachedData.setCacheValid(false);
        //从db查询数据
        Product product1 = cachedData.processCachedData(this::queryDataFromDb);
        System.out.println(product1);

    }

    @Test
    public void testProduct() throws InterruptedException {
        new Thread(this::saveProduct).start();
        Thread.sleep(50);
        final String productName = "trunk";
        //下单线程1
        new Thread(()->{
            Product product = queryProduct(productName);
            if(Objects.nonNull(product)){
                System.out.println("用户拿着这个"+product.getName()+"下单了，价格:"+product.getPrice()+
                        "赠送优惠券"+product.getCoupon());
            }
        }).start();
        Thread.sleep(50);
        //更新商品
        new Thread(()->updateProduct(productName)).start();
        Thread.sleep(50);
        //模拟并发写缓存
        //多个线程同时下单
        //下单线程2
        new Thread(()->{
            Product product = queryProduct(productName);
            if(Objects.nonNull(product)){
                System.out.println("用户拿着这个"+product.getName()+"下单了，价格:"+product.getPrice()+
                        "赠送优惠券"+product.getCoupon());
            }
        }).start();
        //下单线程3
        new Thread(()->{
            Product product = queryProduct(productName);
            if(Objects.nonNull(product)){
                System.out.println("用户拿着这个"+product.getName()+"下单了，价格:"+product.getPrice()+
                        "赠送优惠券"+product.getCoupon());
            }
        }).start();
        while (true){

        }
    }

    /**
     * 商品上架 （保存商品）
     * @return
     */
    public int saveProduct(){
        String productName = "trunk";
        Product product = new Product(productName,200,150);
        //保存数据到数据库
        mockDataBase.put(productName,product);
        return 1;
    }

    /**
     * 查询商品信息
     * @param productName
     * @return
     */
    public Product queryProduct(String productName){
        CachedData<Product> cacheData = getCacheData(productName);
        return cacheData.processCachedData(()->mockDataBase.get(productName));
    }

    private CachedData<Product> getCacheData(String productName) {
//        //操作1
//        CachedData<Product> cachedData = map.get(productName);
//        if(cachedData==null){
//            map.put(productName,new CachedData<>());
//        }
        //操作2
        return map.compute(productName, (k, v) -> {
            if (v == null) {
                return new CachedData<>();
            } else {
                return v;
            }
        });
    }

    /**
     * 更新商品
     * @param productName
     * @return
     */
    public int updateProduct(String productName){
        Product product = queryProduct(productName);
        if(Objects.isNull(product)){
            return 0;
        }
        product.updateProductInfo(150,100);
        mockDataBase.put(productName,product);
        CachedData<Product> cacheData = getCacheData(productName);
        cacheData.setCacheValid(false);
        map.put(productName,cacheData);
        return 1;
    }

    /**
     * 商品下架
     * @return
     */
    public int deleteProduct(String productName){
        //查询商品
        Product product = queryProduct(productName);
        if(Objects.isNull(product)){
            return 0;
        }
        mockDataBase.remove(productName);
        map.remove(productName);
        return 1;
    }

    private Product queryDataFromDb() {
        return new Product("trunk",150,100);
    }
}

package imooc4.lock.demo;

/**
 * @Description:
 */
public class TestProduct {
    public static void main(String[] args) throws InterruptedException {
        Product product = new Product("拉杆箱",200,150);
        System.out.println(product);
        Thread writeThread = new Thread(()->{
            product.updateProductInfo(150,100);
        });
        Thread readThread = new Thread(() -> {
            double price = product.getPrice();
            double coupon = product.getCoupon();
            System.out.println(price);
            System.out.println(coupon);
        });
        writeThread.start();
        Thread.sleep(500);
        readThread.start();
//        System.out.println(product);
    }
}

9.（共享锁）信号量Semaphore的应用场景

参考：Java并发神器Semaphore全方位解析_java semaphore-CSDN博客

实现限流器逻辑：

package imooc4.semaphore;

import java.util.concurrent.Semaphore;
import java.util.function.Supplier;

/**
 * @Description:使用semaphore实现限流功能
 */
public class LimitedTask<T> implements Runnable{

    private String name;
    private Semaphore semaphore;
    private Supplier<T> supplier;

    public LimitedTask(String name, Semaphore semaphore,Supplier<T> supplier) {
        this.name = name;
        this.semaphore = semaphore;
        this.supplier = supplier;
    }

    @Override
    public void run() {
        try {
            //请求许可，如果许可不足，会被阻塞直到有可用的许可
            semaphore.acquire();
            System.out.println(name+" 正在执行");
            supplier.get();
            System.out.println(name+" 执行结束");
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }finally {
            semaphore.release();
        }
    }
}

package imooc4.semaphore;

import java.util.concurrent.Semaphore;

/**
 * @Description:
 */
public class TestLimitedTask {
    public static void main(String[] args) {
        int maxTaskCount = 2;
        Semaphore semaphore = new Semaphore(maxTaskCount);
        //启动多个线程，交给LimitedTask去执行
        for (int i = 0; i <= 5; i++) {
            String taskName = "Task "+i;
            Thread thread = new Thread(new LimitedTask(taskName, semaphore,()->{
                //下单的逻辑
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                return taskName;
            }));
            thread.start();
        }
    }
}

运行结果：

实现资源池逻辑：

package imooc4.semaphore;

import java.util.concurrent.Semaphore;

/**
 * @Description:
 */
public class ObjectPool<T> {
    //资源池大小
    private final int poolSize;
    //semaphore大小跟资源池大小一样
    private final Semaphore semaphore;
    //对象都有哪些
    private final T[] objects;
    //对象是否使用
    private final boolean[] isUsed;
    public ObjectPool( T[] objects) {
        this.poolSize = objects.length;
        this.semaphore = new Semaphore(poolSize);
        this.objects = objects;
        this.isUsed = new boolean[poolSize];
    }
    //获取许可
    public T acquire() throws InterruptedException {
        //拿到许可后获取对象池中的对象
        semaphore.acquire();
        return getObject();
    }

    //释放许可
    public void release(T obj){
        if(returnObject(obj)){
            semaphore.release();
        }
    }

    private synchronized boolean returnObject(T obj) {
        for (int i = 0; i < poolSize; i++) {
            if(objects[i]==obj&&isUsed[i]){
                isUsed[i] = false;
                return true;
            }
        }
        return false;
    }

    private synchronized T getObject() {
        for (int i = 0; i < poolSize; i++) {
            if(!isUsed[i]){
                isUsed[i] = true;
                return objects[i];
            }
        }
        return null;
    }
}

package imooc4.semaphore;

/**
 * @Description:测试对象池
 */
public class TestObjectPool {
    public static void main(String[] args) {
        Integer[] poolObjects = new Integer[]{1,2,3,4,5};
        ObjectPool<Integer> objectPool = new ObjectPool<>(poolObjects);
        //创建多个线程获取对象池中的对象
        for (int i = 0; i < 7; i++) {
            new Thread(()->{
                try {
                    Integer obj = objectPool.acquire();
                    if(obj!=null){
                        System.out.println(Thread.currentThread().getName()+" 获取到了： "+ obj);
                        Thread.sleep(3000);
                        objectPool.release(obj);
                    }else{
                        System.out.println(Thread.currentThread().getName()+"对象池耗尽");
                    }
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }).start();
        }
    }
}

运行结果：

10.（死锁）：什么是死锁？如何排查死锁问题？

演示代码：

package imooc4.lock.deadlock;

/**
 * @Description:
 */
public class TestDeadLock {
    public static void main(String[] args) {
        Object lock = new Object();
        Object lock1 = new Object();
        new Thread(()->{
            synchronized (lock){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (lock1){
                    System.out.println("拿到锁");
                }
            }
        }).start();

        new Thread(()->{
            synchronized (lock1){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (lock){
                    System.out.println("拿到锁");
                }
            }
        }).start();
    }
}

运行结果：

结论：

两个线程一直没有停止。

通过JVM命令查看：

在真实的业务中死锁一般不容易察觉！

代码示例：

package imooc4.lock.deadlock;

/**
 * @Description:
 */
public class Coupon {
    private String id;
    private String displayName;
    private Long amount;
    private Member member;
    public synchronized Long getAmount(){
        return this.amount;
    }
    public synchronized void setAmount(Long amount) throws InterruptedException {
        this.amount = amount;
        if(amount==0){
            Thread.sleep(1000);
            //从member移除这个优惠券
            member.removeCoupon(id);
        }

    }

    public String getId() {
        return id;
    }

    public Coupon(String id, String displayName, Long amount, Member member) {
        this.id = id;
        this.displayName = displayName;
        this.amount = amount;
        this.member = member;
    }
}

package imooc4.lock.deadlock;

import java.util.ArrayList;
import java.util.List;

/**
 * @Description:
 */
public class Member {
    private String id;
    private  String name;
    private String address;
    private List<Coupon> coupons;

    public synchronized void removeCoupon(String id) {
        this.coupons.removeIf(coupon -> id.equals(coupon.getId()));
    }

    public String getId() {
        return id;
    }

    public synchronized Long getAllCouponsAmount() throws InterruptedException {
        Long result = 0L;
        Thread.sleep(1000);
        for (Coupon coupon : coupons) {
            result+=coupon.getAmount();
        }
        return result;
    }

    public Member(String id, String name, String address) {
        this.id = id;
        this.name = name;
        this.address = address;
    }

    public void setCoupons(List<Coupon> coupons) {
        this.coupons = coupons;
    }
}

package imooc4.lock.deadlock;

import java.util.ArrayList;
import java.util.List;

/**
 * @Description:
 */
public class TestMember {
    public static void main(String[] args) throws InterruptedException {
        //构建对象
        Member member = new Member("1","慕课","北京");
        Coupon coupon = new Coupon("1","coupon1",200L,member);
        Coupon coupon1 = new Coupon("2","coupon2",150L,member);
        Coupon coupon2 = new Coupon("3","coupon3",100L,member);
        List<Coupon> couponList = new ArrayList<>();
        couponList.add(coupon);
        couponList.add(coupon1);
        couponList.add(coupon2);
        member.setCoupons(couponList);

        Thread thread = new Thread(() -> {
            try {
                coupon.setAmount(0L);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        Thread thread1 = new Thread(() -> {
            try {
                Long allCouponsAmount = member.getAllCouponsAmount();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        thread.start();
        thread1.start();
        thread.join();
        thread1.join();
        System.out.println("运行结束");

    }
}

11.（死锁）形成死锁的条件与如何避免死锁？

优化代码：

package imooc4.lock.deadlock;

/**
 * @Description:
 */
public class Coupon {
    private String id;
    private String displayName;
    private Long amount;
    private Member member;
    public synchronized Long getAmount(){
        return this.amount;
    }
    public  void setAmount(Long amount) throws InterruptedException {
        synchronized(this){
            this.amount = amount;
        }
        if(amount==0){
            Thread.sleep(1000);
            //从member移除这个优惠券
            member.removeCoupon(id);
        }

    }

    public String getId() {
        return id;
    }

    public Coupon(String id, String displayName, Long amount, Member member) {
        this.id = id;
        this.displayName = displayName;
        this.amount = amount;
        this.member = member;
    }
}

package imooc4.lock.deadlock;

import java.util.ArrayList;
import java.util.List;

/**
 * @Description:
 */
public class Member {
    private String id;
    private  String name;
    private String address;
    private List<Coupon> coupons;

    public synchronized void removeCoupon(String id) {
        this.coupons.removeIf(coupon -> id.equals(coupon.getId()));
    }

    public String getId() {
        return id;
    }

    public synchronized Long getAllCouponsAmount() throws InterruptedException {
        Long result = 0L;
        Thread.sleep(1000);
        List<Coupon> temps = new ArrayList<>(coupons);
        for (Coupon coupon : temps) {
            result+=coupon.getAmount();
        }
        return result;
    }

    public Member(String id, String name, String address) {
        this.id = id;
        this.name = name;
        this.address = address;
    }

    public void setCoupons(List<Coupon> coupons) {
        this.coupons = coupons;
    }
}

package imooc4.lock.deadlock;

import java.util.ArrayList;
import java.util.List;

/**
 * @Description:
 */
public class TestMember {
    public static void main(String[] args) throws InterruptedException {
        //构建对象
        Member member = new Member("1","慕课","北京");
        Coupon coupon = new Coupon("1","coupon1",200L,member);
        Coupon coupon1 = new Coupon("2","coupon2",150L,member);
        Coupon coupon2 = new Coupon("3","coupon3",100L,member);
        List<Coupon> couponList = new ArrayList<>();
        couponList.add(coupon);
        couponList.add(coupon1);
        couponList.add(coupon2);
        member.setCoupons(couponList);

        Thread thread = new Thread(() -> {
            try {
                coupon.setAmount(0L);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        Thread thread1 = new Thread(() -> {
            try {
                Long allCouponsAmount = member.getAllCouponsAmount();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        thread.start();
        thread1.start();
        thread.join();
        thread1.join();
        System.out.println("运行结束");

    }
}

运行结果：