ConcurrentHashMap

位运算

位运算控制CRUD权限

@Data
public class TestDemo {
    //查询权限
    public static final int ALLOW_SELECT = 1 << 0;//0001
    //插入权限
    public static final int ALLOW_INSERT = 1 << 1;//0010
    //更新权限
    public static final int ALLOW_UPDATE = 1 << 2;//0100
    //删除权限
    public static final int ALLOW_DELETE = 1 << 3;//1000
    //权限状态
    private int flag;

    //设置用户权限
    public void setPer(int per) {
        flag = per;
    }

    //再增加用户权限，1个或者多个
    public void enable(int per) {
        flag = flag | per;
    }

    //删除用户权限
    public void disable(int per) {
        flag = flag & ~per;
    }

    //判断用户权限
    public Boolean isAllow(int per) {
        return ((flag & per) == per);
    }

    //判断用户没有的权限
    public Boolean isNotAllow(int per) {
        return ((flag & per) == 0);
    }

    @Test
    public void testDemo1() {
        //默认全部权限
        int flag = 15;
        TestDemo testDemo = new TestDemo();
        testDemo.setFlag(flag);
        //去除掉删除和更新权限
        testDemo.disable(ALLOW_DELETE | ALLOW_UPDATE);
        System.out.println("ALLOW_SELECT=" + testDemo.isAllow(ALLOW_SELECT));
        System.out.println("ALLOW_DELETE=" + testDemo.isAllow(ALLOW_DELETE));
        System.out.println("ALLOW_UPDATE=" + testDemo.isAllow(ALLOW_UPDATE));
        System.out.println("ALLOW_INSERT=" + testDemo.isAllow(ALLOW_INSERT));
    }
}

ALLOW_SELECT=true
ALLOW_DELETE=false
ALLOW_UPDATE=false
ALLOW_INSERT=true

JDK1.8后的实现

与1.7相比

主要数据结构和关键变量

Put时候做了什么

数据的实际初始化

Get时候做了什么

扩容

更多并发容器

ConcurrentSkipListMap, ConcurrentSkipListSet

链表和跳表

为什么hashMap不适应跳表

ConcurrentLinkedQueue

阻塞队列

概念

生产者和消费者

延迟队列实战

/*
 * 实现一个订单延迟功能,实现Delayed接口。重写compareTo，getDelay方法
 * 这里框架针对于超时取消通用
 * */
public class ItemVo<T> implements Delayed {
    //数据
    private T date;
    //订单的过期时间 ms单位
    private long activeTime;

    public ItemVo(T date, long activeTime) {
        this.date = date;
        //将时间转换为ns,加上当前纳秒数
        this.activeTime = TimeUnit.NANOSECONDS.convert(activeTime, TimeUnit.MILLISECONDS) + System.nanoTime();
    }

    public T getDate() {
        return date;
    }

    public long getActiveTime() {
        return activeTime;
    }
    @Override
    public int compareTo(Delayed o) {
        long d = getDelay(TimeUnit.NANOSECONDS) - o.getDelay(TimeUnit.NANOSECONDS);
        return (d == 0) ? 0 : (d > 0 ? 1 : -1);
    }

    //返回元素剩余的时间
    @Override
    public long getDelay(TimeUnit unit) {
        long d = unit.convert(this.activeTime - System.nanoTime(), TimeUnit.NANOSECONDS);
        return d;
    }
}

/*
* 订单实体类
* */
public class OrderBean {
    //订单号
    private String code;
    //订单金额
    private Integer money;

    public OrderBean(String code, Integer money) {
        this.code = code;
        this.money = money;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public Integer getMoney() {
        return money;
    }

    public void setMoney(Integer money) {
        this.money = money;
    }
}

public class TestDemo {
    private DelayQueue<ItemVo<OrderBean>> delayQueue;

    public TestDemo(DelayQueue<ItemVo<OrderBean>> delayQueue) {
        this.delayQueue = delayQueue;
    }

    //插入数据
    public Thread setOrder() {
        return new Thread(() -> {
            //5s后过期
            OrderBean tb = new OrderBean("TB2022040401", 888);
            ItemVo<OrderBean> tbVo = new ItemVo<>(tb, 2000);
            delayQueue.add(tbVo);
            System.out.println("淘宝订单2s后到期：" + tb.getCode());
            //6s后过期
            OrderBean jd = new OrderBean("JD2022040401", 888);
            ItemVo<OrderBean> jdVo = new ItemVo<>(jd, 2000);
            delayQueue.add(jdVo);
            System.out.println("京东订单2s后到期：" + jd.getCode());
        });
    }

    //获取过期的数据
    public Thread getOrder() {
        return new Thread(() -> {
            while (true) {
                try {
                    ItemVo<OrderBean> take = delayQueue.take();
                    OrderBean date = (OrderBean) take.getDate();
                    System.out.println("拿到过期的订单：" + date.getCode());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        });
    }

    public static void main(String[] args) {
        DelayQueue<ItemVo<OrderBean>> itemVos = new DelayQueue<>();
        TestDemo testDemo = new TestDemo(itemVos);
        Thread setThread = testDemo.setOrder();
        Thread getThread = testDemo.getOrder();
        setThread.start();
        getThread.start();
    }
}

淘宝订单2s后到期：TB2022040401
京东订单2s后到期：JD2022040401
拿到过期的订单：TB2022040401
拿到过期的订单：JD2022040401

面试常问