Super_Song_

Java多线程进阶之JUC并发编程教程详解（狂神说学习笔记）

文章目录

- - - 环境准备
1.JUC 简介
2.线程和进程
- - - 线程和进行
    - 并发和并行
    - 线程的状态
    - wait/sleep的区别
3.Lock 锁（重点）
- - - Synchronized 传统的锁
    - Lock锁
    - synchronized 和 lock 锁的区别
4.生产者和消费者问题
- - - Synchronized 版本
    - JUC 版本
5.八个有关锁的问题
- - - 问题1：两个同步方法，先执行发短信还是打电话？
    - 问题2：如果发短信延迟2秒，谁先执行
    - 问题3 加上一个没有锁的普通方法，谁先执行
    - 问题4：两个对象，一个调用发短信，一个调用打电话，谁先执行
    - 问题5：原来的两个同步方法，变为静态同步方法，一个对象调用，谁先执行
    - 问题6：创建两个实例，调用两个静态同步方法，谁先执行
    - 问题7：一个静态同步方法、一个同步方法、一个对象调用，谁先执行
    - 问题8：两个对象，一个调用静态同步方法，一个调用普通同步方法，谁先执行
    - 小结
6.集合类的安全问题
- - - List 不安全
    - Set 不安全
    - HashMap 不安全
7.Callable（简单）
8.JUC 常用辅助类
- - - CountDownLatch
    - CyclickBarrier
    - Semaphore
9.ReadWriteLock 读写锁
10.阻塞队列
- - - Blockqueue
    - SynchronizedQueue 同步队列
11.线程池（重点）
- - - 池化技术
    - 线程池：三大方法
    - 线程池：七大参数
    - 四种拒绝策略
    - 如何设置线程池的最大值（maximumPoolSize）
12.四大函数式接口（重点）
- - - Function 函数型接口
    - Predicate 断定型接口
    - Suppier 供给型接口
    - Consummer 消费型接口
    - 小结：函数式接口的作用
13.Stream 流式计算
14.ForkJoin 分之合并
- - - ForkJoin 特点：工作窃取
    - 如何使用ForkJoin
15.异步回调
16.JMM
- - - 谈谈对 Volatile 的理解
    - 什么是 JMM
17.Volatile
- - - 保证可见性
    - 不保证原子性
    - 禁止指令重排
    - 小结
18.玩转单例模式
- - - 饿汉模式
    - 懒汉模式
    - DCL 懒汉式
    - 静态内部类实现单例
    - 反射可以破坏单例
    - 枚举
19.深入理解CAS
- - - 什么是CAS
    - 小结
    - ABA 问题
20.原子引用
21.各种锁的理解
- - - 公平锁、非公平锁
    - 可重入锁（递归锁）
    - 自旋锁
    - 死锁

环境准备

创建普通的maven项目，确保我们的项目一定是在Java8的环境下，检查settings中的以下几点


添加一个 lombok 依赖

1.JUC 简介

什么是 JUC ？

JUC 就是 java.util.concurrent 下面的类包，专门用于多线程的开发

为什么使用 JUC ?

以往我们所学，普通的线程代码，都是用的thread或者runnable接口
但是相比于callable来说，thread没有返回值，且效率没有callable高

2.线程和进程

线程和进行

线程是进程中的一个实体，线程本身是不会独立存在的。
进程是代码在数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位。
线程则是进程的一个执行路径，一个进程中至少有一个线程，进程中的多个线程共享进程的资源。
操作系统在分配资源时是把资源分配给进程的，但是CPU 资源比较特殊，它是被分配到线程的，因为真正要占用CPU 运行的是线程，所以也说线程是CPU 分配的基本单位。
java默认有几个线程? 两个 main线程 gc线程
Java 中，使用 Thread、Runnable、Callable 开启线程。
Java 没有权限开启线程、Thread.start() 方法调用了一个 native 方法 start0()，它调用了底层 C++ 代码。

查看源码可以发现，start方法底层调用了本地方法，本地方法就是C语言提供的

//本地方法,调用底层c++, java无法操作硬件
private native void start0();

并发和并行

并发(多线程操作同一个资源,交替执行)

CPU一核, 模拟出来多条线程,天下武功,唯快不破,快速交替

并行(多个人一起行走, 同时进行)

CPU多核,多个线程同时进行 ; 使用线程池操作

代码检测当前CPU核数

public class TestCore {
     
    public static void main(String[] args) {
     
        // 获取cpu核数
        // cpu密集型,IO密集型
        System.out.println(Runtime.getRuntime().availableProcessors());
    }
}

并发编程的本质: 充分利用CPU的资源

线程的状态

查看Thread源码，可以发现枚举类State

public enum State {
     
       // 新生
        NEW,
        // 运行
        RUNNABLE,
        // 阻塞
        BLOCKED,
        // 等待，死等
        WAITING,
        //超时等待
        TIMED_WAITING,
        //终止
        TERMINATED;
    }

wait/sleep的区别

来自不同的类：wait来自object类, sleep来自线程类
关于锁的释放：wait会释放锁, sleep不会释放锁
使用范围不同：wait必须在同步代码块中，sleep可以在任何地方睡
是否需要捕获异常：wait不需要捕获异常，sleep需要捕获异常

3.Lock 锁（重点）

Synchronized 传统的锁

之前我们所学的使用线程的传统思路是：

单独创建一个线程类，继承Thread或者实现Runnable
在这个线程类中，重写run方法，同时添加相应的业务逻辑
在主线程所在方法中new上面的线程对象，调用start方法启动

比如，

//线程不安全：买票例子
//线程不安全，输出结果有买重票有负数票
public class UnsafeBuyTicket {
     
    public static void main(String[] args) {
     
        BuyTicket station = new BuyTicket();
        new Thread(station,"抢票的我").start();
        new Thread(station,"买票的你们").start();
        new Thread(station,"可恶的黄牛党").start();
    }
}
class BuyTicket implements Runnable{
     
    //票
    private int ticketNums = 10;
    //外部停止方式
    boolean flag = true;
    @Override
    public void run() {
     
        //买票
        while (true){
     
            if (flag){
     
                try {
     
                    buy();
                } catch (InterruptedException e) {
     
                    e.printStackTrace();
                }
            }else {
     
                break;
            }
        }
    }
    private void buy() throws InterruptedException {
     
        //判断是否有票
        if (ticketNums <= 0){
     
            flag = false;
            return;
        }
        //模拟延时，放大问题
        Thread.sleep(100);
        //买票
        System.out.println(Thread.currentThread().getName()+"--> 拿到第 "+ ticketNums--+" 张票");
    }
}

但是这样写代码有诸多问题，不太符合OOP思想，增加耦合性等问题，

实际工作的使用线程的思路是：

创建一个独立的类只作为资源类，存放属性、方法，所以在多线程中我们需要锁这个公共资源
线程类主要作为工具使用，用于开启多线程，把资源类实例丢到线程类的重写run方法中执行业务
在我们的业务类中，比如主线程中，创建若干个线程类实例，去操作资源类

比如，这里我们使用了实现Runnable的方法创建线程，还是用了lambda表达式来创建Runnable实例

public class TestCore {
     
    public static void main(String[] args) {
     
        Ticket ticket = new Ticket();
        new Thread(()->{
     
            for (int i = 0; i < 100; i++) {
     
                ticket.sale();
            }
        }).start();
        new Thread(()->{
     
            for (int i = 0; i < 100; i++) {
     
                ticket.sale();
            }
        }).start();
        new Thread(()->{
     
            for (int i = 0; i < 100; i++) {
     
                ticket.sale();
            }
        }).start();
    }
}
//  这是一个资源类，存放属性、方法
class Ticket{
     
    private int number = 300;
    public synchronized void sale(){
     
        if(number>0){
     
            System.out.println(Thread.currentThread().getName()+"get "+number+"#");
            number--;
        }
    }
}

这需要我们在工作加以注意

Lock锁

查看 api 文档


可以看到，Lock是一个接口，有三个实现类，现在我们使用 ReentrantLock 就够用了

查看 ReentrantLock 源码，构造器

公平非公平：

公平锁:：十分公平，可以先来后到，一定要排队
非公平锁:：十分不公平，可以插队（默认）

ReentrantLock 构造器

ReentrantLock 默认的构造方法是非公平锁（可以插队）。
如果在构造方法中传入 true 则构造公平锁（不可以插队，先来后到）。

我们将上面的抢票代码改造为

public class SaleTicketDemo {
     
    public static void main(String[] args) {
     
        Ticket ticket = new Ticket();
        new Thread(()->{
     for(int i = 0; i < 40; i++) ticket.sale();}, "a").start();
        new Thread(()->{
     for(int i = 0; i < 40; i++) ticket.sale();}, "b").start();
        new Thread(()->{
     for(int i = 0; i < 40; i++) ticket.sale();}, "c").start();
    }
}
class Ticket {
     
    private int ticketNum = 30;
    private Lock lock = new ReentrantLock();
    public void sale() {
     
        lock.lock();
        try {
     
            if (this.ticketNum > 0) {
     
                System.out.println(Thread.currentThread().getName() + "购得第" + ticketNum-- + "张票, 剩余" + ticketNum + "张票");
            }
            //增加错误的发生几率
            Thread.sleep(10);
        } catch (Exception e) {
     
            e.printStackTrace();
        } finally {
     
            lock.unlock();
        }
    }
}

运行，发现，多线程都有几率抢到票，且没有出现线程安全问题

综述，Lock 锁实现步骤：

创建锁，new ReentrantLock()
加锁，lock.lock()
解锁，lock.unlock()
基本结构固定，中间的业务自己灵活修改

synchronized 和 lock 锁的区别

synchronized 是内置的 Java 关键字，Lock 是一个 Java 类
synchronized 无法判断获取锁的状态，Lock可以判断是否获取到了锁
synchronized 会自动释放锁，Lock 必须要手动释放锁！如果不释放锁，会产生死锁
synchronized 假设线程1（获得锁，然后发生阻塞），线程2（一直等待）； Lock 锁就不一定会等待下去，可使用 tryLock 尝试获取锁
synchronized 可重入锁，不可以中断的，非公平的；Lock锁，可重入的，可以判断锁，是否公平（可自己设置）
synchronized 适合锁少量的代码同步问题，Lock 适合锁大量的同步代码

总体来说，synchronized 本来就是一个关键字，很多规则都是定死的，灵活性差；Lock 是一个类，灵活性高

思考问题：什么是锁？锁的是什么？

4.生产者和消费者问题

面试高频考点：

单例模式、八大排序、生产者消费者、死锁

Synchronized 版本

解决线程之间的通信问题，比如线程操作一个公共的资源类

基本流程可以总结为：

等待：判断是否需要等待
业务：执行相应的业务
通知：执行完业务通知其他线程

public class ConsumeAndProduct {
     
    public static void main(String[] args) {
     
        Data data = new Data();
        // 创建一个生产者
        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();
    }
}
//这是一个缓冲类，生产和消费之间的仓库,公共资源类
class Data{
     
    // 这是仓库的资源，生产者生产资源，消费者消费资源
    private int num = 0;
    // +1，利用关键字加锁
    public synchronized void increment() throws InterruptedException {
     
        // 首先查看仓库中的资源(num)，如果资源不为0，就利用 wait 方法等待消费，释放锁
        if(num!=0){
     
            this.wait();
        }
        num++;
        System.out.println(Thread.currentThread().getName()+"=>"+num);
        // 通知其他线程 +1 执行完毕
        this.notifyAll();
    }
    // -1
    public synchronized void decrement() throws InterruptedException {
     
        // 首先查看仓库中的资源(num)，如果资源为0，就利用 wait 方法等待生产，释放锁
        if(num==0){
     
            this.wait();
        }
        num--;
        System.out.println(Thread.currentThread().getName()+"=>"+num);
        // 通知其他线程 -1 执行完毕
        this.notifyAll();
    }
}

思考问题：如果存在ABCD4个线程是否安全？

不安全，会有虚假唤醒

查看 api 文档

解决办法：if 判断改为 while，防止虚假唤醒

因为 if 只会执行一次，执行完会接着向下执行 if() 外边的代码
而 while 不会，直到条件满足才会向下执行 while() 外边的代码

修改代码为：

		// ...
  		// 使用 if 存在虚假唤醒
        while (num!=0){
     
            this.wait();
        }
        // ...
        while(num==0){
     
            this.wait();
        }

JUC 版本

锁、等待、唤醒都进行了更换


将代码改造为 JUC 版本的生产者和消费者模式，这里我们使用四个线程，ABCD，两个生产者，两个消费者，

改造之后，确实可以实现01切换，但是ABCD是无序的，不满足我们的要求，

package com.swy.pc;

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

/**
 * @author SuperSong
 * @version 1.0.0
 * @ClassName juc-study.com.swy.pc.ConsumeAndProduct.java
 * @Description TODO
 * @createTime 2021年04月25日 07:47:00
 */
public class ConsumeAndProductLock {
     
    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();
    public void increment() throws InterruptedException {
     
        lock.lock();
        try {
     
            while (num != 0) {
     
                condition.await();
            }
            num++;
            System.out.println(Thread.currentThread().getName() + "=>" + num);
            condition.signalAll();
        } catch (Exception e) {
     
            e.printStackTrace();
        } finally {
     
            lock.unlock();
        }
    }
    public void decrement() throws InterruptedException {
     
        lock.lock();
        try {
     
            while (num == 0) {
     
                condition.await();
            }
            num--;
            System.out.println(Thread.currentThread().getName() + "=>" + num);
            condition.signalAll();
        } catch (Exception e) {
     
            e.printStackTrace();
        } finally {
     
            lock.unlock();
        }
    }
}

Condition 的优势在于，精准的通知和唤醒线程！比如，指定通知下一个进行顺序。

重新举个例子，

三个线程 A执行完调用B，B执行完调用C，C执行完调用A，分别用不同的监视器，执行完业务后指定唤醒哪一个监视器，实现线程的顺序执行

锁是统一的，但监视器是分别指定的，分别唤醒，signal，之前使用的是 signalAll

// A执行完调用B,B执行完调用C,C执行完调用A
public class ConditionDemo {
     
    public static void main(String[] args) {
     
        Data3 data3 = new Data3();
        new Thread(()->{
     
            for (int i = 0; i < 10; i++) {
     
                data3.printA();
            }
        },"A").start();
        new Thread(()->{
     
            for (int i = 0; i < 10; i++) {
     
                data3.printB();
            }
        },"B").start();
        new Thread(()->{
     
            for (int i = 0; i < 10; i++) {
     
                data3.printC();
            }
        },"C").start();
    }
}
class Data3 {
     
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    private int num = 1; // 1A 2B 3C
    public void printA(){
     
        lock.lock();
        try {
     
            while (num != 1){
     
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName() + " Im A ");
            num = 2;
            condition2.signal();
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        } finally {
     
            lock.unlock();
        }
    }
    public void printB(){
     
        lock.lock();
        try {
     
            while (num != 2){
     
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName() + " Im B ");
            num = 3;
            condition3.signal();
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        } finally {
     
            lock.unlock();
        }
    }
    public void printC(){
     
        lock.lock();
        try {
     
            while (num != 3) {
     
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName() + " Im C ");
            num = 1;
            condition1.signal();
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        } finally {
     
            lock.unlock();
        }
    }
}

5.八个有关锁的问题

深入理解锁

关于锁的八个问题

问题1：两个同步方法，先执行发短信还是打电话？

标准情况下，两个线程，先发短信还是先打电话？

public class Test1 {
     
    public static void main(String[] args) {
     
        Phone phone = new Phone();
        new Thread(()->{
     
            phone.sendMsg();
        }).start();
        try {
     
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }
        new Thread(()->{
     
            phone.call();
        }).start();
    }
}
// 可视作资源类
class Phone{
     
    public synchronized void sendMsg(){
     
        System.out.println("发短信");
    }
    public synchronized void call(){
     
        System.out.println("打电话");
    }
}

经过测试，一直是先发短信

问题2：如果发短信延迟2秒，谁先执行

public class Test1 {
     
    public static void main(String[] args) {
     
        Phone phone = new Phone();
        new Thread(()->{
     
            phone.sendMsg();
        }).start();
        try {
     
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }
        new Thread(()->{
     
            phone.call();
        }).start();
    }
}
// 可视作资源类
class Phone{
     
    public synchronized void sendMsg(){
     
        try {
     
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
     
        System.out.println("打电话");
    }
}

结果依旧是先发短信，后打电话

分析：

并不是由于发短信在前导致的
本案例中，方法前加synchronized，锁的其实该方法的调用者，也就是 phone 实例，两个方法共用同一个 phone 对象的锁，谁先拿到，谁先执行
在主线程中，先调用发短信，所以先执行，打电话等释放锁再执行

问题3 加上一个没有锁的普通方法，谁先执行

public class Test2 {
     
    public static void main(String[] args) {
     
        Phone2 phone2 = new Phone2();
        new Thread(()->{
     
            phone2.sendMsg();
        }).start();
        try {
     
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }
        new Thread(()->{
     
            phone2.hello();
        }).start();
    }
}
// 可视作资源类
class Phone2 {
     
    public synchronized void sendMsg(){
     
        try {
     
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
     
        System.out.println("打电话");
    }
    public void hello(){
     
        System.out.println("hello");
    }
}

观察发现，先执行了 hello

分析原因：

hello 是一个普通方法，不受 synchronized 锁的影响，不用等待锁释放。

问题4：两个对象，一个调用发短信，一个调用打电话，谁先执行

public class Test2 {
     
    public static void main(String[] args) {
     
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();
        new Thread(()->{
     
            phone1.sendMsg();
        }).start();
        try {
     
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }
        new Thread(()->{
     
            phone2.call();
        }).start();
    }
}
// 可视作资源类
class Phone2 {
     
    public synchronized void sendMsg(){
     
        try {
     
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
     
        System.out.println("打电话");
    }
    public void hello(){
     
        System.out.println("hello");
    }
}

结论，先打电话，后发短信

分析原因：

两个对象两把锁，互不影响，1拿到锁还需要等待3秒，2拿到对象立刻就能打电话

问题5：原来的两个同步方法，变为静态同步方法，一个对象调用，谁先执行

public class Test3 {
     
    public static void main(String[] args) {
     
        Phone3 phone = new Phone3();
        new Thread(() -> {
     
            phone.sendMessage();
        }, "A").start();
        try {
     
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }

        new Thread(() -> {
     
            phone.call();
        }, "B").start();
    }
}
class Phone3 {
     
    public static synchronized void sendMessage() {
     
        try {
     
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "发短信");
    }
    public static synchronized void call() {
     
        System.out.println(Thread.currentThread().getName() + "打电话");
    }
}

结果，始终是先发短信，后打电话

分析原因：

静态方法前面加锁，锁的其实是这个方法所在的Class类对象（非静态那个是实例对象，注意区分）
Class类对象也是全局唯一，使用的是通一把锁，所以先发短信，后打电话
虽然和上面的实例对象都是对应了全局唯一的锁，但原理还是有所不同
主线程先执行了发短信，打电话就必须等锁释放再执行

问题6：创建两个实例，调用两个静态同步方法，谁先执行

public class Test3 {
     
    public static void main(String[] args) {
     
        Phone3 phone2 = new Phone3();
        Phone3 phone3 = new Phone3();
        new Thread(() -> {
     
            phone2.sendMessage();
        }, "A").start();
        try {
     
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }

        new Thread(() -> {
     
            phone3.call();
        }, "B").start();
    }
}
class Phone3 {
     
    public static synchronized void sendMessage() {
     
        try {
     
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "发短信");
    }
    public static synchronized void call() {
     
        System.out.println(Thread.currentThread().getName() + "打电话");
    }
}

结果，现发短信，后打电话

原因分析：

虽然实例对象是两个，但是两个静态同步方法对应的锁是Class类对象的锁，还是全局唯一

问题7：一个静态同步方法、一个同步方法、一个对象调用，谁先执行

public class Test4 {
     
    public static void main(String[] args) {
     
        Phone4 phone = new Phone4();
        new Thread(()->{
     
            phone.sendMsg();
        }).start();
        try {
     
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }
        new Thread(()->{
     
            phone.call();
        }).start();
    }
}
// 可视作资源类
class Phone4 {
     
    public static synchronized void sendMsg(){
     
        try {
     
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
     
        System.out.println("打电话");
    }
    public void hello(){
     
        System.out.println("hello");
    }
}

结果：先打电话，后发短信

原因分析：

静态同步方法和普通同步方法分别对应了不同的锁，互不干扰
发短信需要延迟3秒，所以打电话先执行了

问题8：两个对象，一个调用静态同步方法，一个调用普通同步方法，谁先执行

public class Test4 {
     
    public static void main(String[] args) {
     
        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();
        new Thread(()->{
     
            phone1.sendMsg();
        }).start();
        try {
     
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }
        new Thread(()->{
     
            phone2.call();
        }).start();
    }
}
// 可视作资源类
class Phone4 {
     
    public static synchronized void sendMsg(){
     
        try {
     
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
     
        System.out.println("打电话");
    }
    public void hello(){
     
        System.out.println("hello");
    }
}

结果，先打电话，后发短信

分析原因：

同问题7相同，两个方法对应了不同的锁，互不干扰
发短信还需要等待3秒，所以打电话先执行完了

小结

无外乎两种锁，一个是new实例的锁，一个是Class对象的锁
实例的锁，与当前的实例唯一对应，Class对象的锁与这个类唯一对应
如果两个方法等同一个锁，必须一个先执行完，释放锁，另一个才可以执行
如果两个方法等不同的锁，互不影响，谁先谁后看具体情况
在主线程中，代码是顺序执行的，再结合锁的原理，综合判断线程执行的顺序

6.集合类的安全问题

在 JUC 并发编程情况下，适用于单线程的集合类将出现并发问题

List 不安全

代码举例

public class ListTest {
     
    public static void main(String[] args) {
     
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
     
            new Thread(()->{
     
                list.add(UUID.randomUUID().toString().substring(0, 5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

运行出现并发修改异常，java.util.ConcurrentModificationException

原因：ArrayList 在并发情况下是不安全的

解决方案1：

ArrayList 换成 Vector，Vector 方法里加了锁
Vector出现比较早，由于锁导致方法执行效率太低，不推荐使用

解决方案2：

使用 Collection 静态方法，返回一个带锁的 List 实例

List<String> list = Collections.synchronizedList(new ArrayList<>());

测试正常使用

解决方案3：

使用 JUC 提供的适合并发使用的 CopyOnWriteArrayList

List<String> list = new CopyOnWriteArrayList<>();

运行测试，没有问题

分析：

CopyOnWrite 表示写入时复制，简称COW，计算机程序设计领域的一种优化策略
多线程调用list时，读取时没有问题，写入的时候会复制一份，避免在写入时被覆盖
这也是一种读写分离的思想
CopyOnWriteArrayList 比 Vector 强在哪里？前者是写入、复制，且使用 lock 锁，效率比 Vector 的synchronized 锁要高很多

CopyOnWriteArrayList 方法，先复制，再修改，再set回去

Set 不安全

Set 和 List 同理可得：多线程情况下，普通的 Set 集合是线程不安全的

public class SetTest {
     
    public static void main(String[] args) {
     
        Set<String> set = new HashSet<>();
        for (int i = 0; i < 20; i++) {
     
            new Thread(()->{
     
                set.add(UUID.randomUUID().toString().substring(0, 5));
                System.out.println(set);
            },String.valueOf(i)).start();
        }
    }
}

注意这里，不一定会立刻出现并发问题，需要多试几次，增加循环线程数量，容易出现问题

解决方案有两种；

使用 Collection 工具类的 synchronized 包装的 Set 类

Set<String> set = Collections.synchronizedSet(new HashSet<>());

使用 JUC 提供的 CopyOnWriteArraySet 写入复制

Set<String> set = new CopyOnWriteArraySet<>();

思考，HashSet 底层到底是什么？

hashSet底层就是一个HashMap；hashSet只使用了hashMap的key

HashMap 不安全

查看 HashMap 源码

默认初始容量 2⁴=16，最大容量为 2³⁰，加载因子 0.75

HashMap 在多线程操作情况下，也有并发修改异常的问题

解决方案：

Map map = Collections.synchronizedMap(new HashMap<>());
Map map = new ConcurrentHashMap<>();

7.Callable（简单）

得到的信息：

可以有返回值
可以抛出异常
方法不同，run() => call()

使用时注意

Callable 的泛型也是 call 方法的返回值类型
Callable 的实现类无法直接放在 Thread 中，还需要先放在 FutureTask 中，再放在 Thread 中
FutureTask 就相当于适配类，起到牵线的作用

public class CallableTest {
     
    public static void main(String[] args) throws ExecutionException, InterruptedException {
     
        FutureTask<Integer> futureTask = new FutureTask<>(new MyThread());
        new Thread(futureTask,"a").start();
        System.out.println(futureTask.get());
    }
}
class MyThread implements Callable<Integer> {
     
    @Override
    public Integer call() throws Exception {
     
        System.out.println("call()方法被调用了");
        return 1024;
    }
}

注意：

运行结果会产生缓存，目的是为了提高效率
get方法可能会产生阻塞，所以放在了最后

8.JUC 常用辅助类

CountDownLatch

减法计数器

//计数器
public class CountDownLatchDemo {
     
    public static void main(String[] args) throws InterruptedException {
     
        // 倒计时总数是6, 必须要执行任务的时候,再使用!
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 0; i < 6; i++) {
     
            new Thread(()->{
     
                System.out.println(Thread.currentThread().getName() + " GO out");
                countDownLatch.countDown();     //数量减1
            },String.valueOf(i)).start();
        }
        countDownLatch.await();// 等待计数器归零,然后再向下执行
        System.out.println("close Door");
    }
}

原理:

countDownLatch.countDown(); //数量减1
countDownLatch.await();// 等待计数器归零,然后再向下执行

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

CyclickBarrier

加法计数器，与 CountDownLatch 正好相反

相当于设定一个目标，线程数达到目标值之后才会执行

public class CyclicBarrierDemo {
     
    public static void main(String[] args) {
     
        // 主线程,计数器到达7即满足条件
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
     
            System.out.println("召唤神龙");
        });
        for (int i = 1; i <= 7; i++) {
     
            // 子线程
            int finalI = i;// 下面thread中拿不到i,所以这里提取出来
            new Thread(()->{
     
                System.out.println(Thread.currentThread().getName()+"收集了第"+finalI+"颗龙珠");
                try {
     
                    cyclicBarrier.await();//加法计数等待
                } catch (InterruptedException e) {
     
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
     
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

Semaphore

计数信号量，比如说，有6辆车，3个停车位，汽车需要轮流等待车位

常用在需要限流的场景中，

public class SemaphoreDemo {
     
    public static void main(String[] args) {
     
        // 线程数量，停车位，限流
        Semaphore semaphore = new Semaphore(3);
        for (int i = 0; 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();// 释放
                }
            }).start();
        }
    }
}

原理：

semaphore.acquire() 获得资源，如果资源已经使用完了，就等待资源释放后再进行使用！
semaphore.release() 释放，会将当前的信号量释放+1，然后唤醒等待的线程！

用途：

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

9.ReadWriteLock 读写锁

代码演示

public class ReadWriteLockDemo {
     
    public static void main(String[] args) {
     
        // 线程操作资源类
        MyCache myCache = new MyCache();
        int num = 6;
        for (int i = 1; i < num; i++) {
     
            int finalI = i;
            new Thread(()->{
     
                myCache.write(String.valueOf(finalI), String.valueOf(finalI));
            },String.valueOf(i)).start();
        }
        for (int i = 1; i < num; i++) {
     
            int finalI = i;
            new Thread(()->{
     
                myCache.read(String.valueOf(finalI));
            },String.valueOf(i)).start();
        }
    }
}
// 自定义缓存
class MyCache{
     
    private volatile Map<String,String> map = new HashMap<>();
    // 存，写
    public void write(String key, String value) {
     
        System.out.println(Thread.currentThread().getName() + "线程开始写入");
        map.put(key, value);
        System.out.println(Thread.currentThread().getName() + "线程开始写入ok");
    }
    // 取，读
    public void read(String key) {
     
        System.out.println(Thread.currentThread().getName() + "线程开始读取");
        map.get(key);
        System.out.println(Thread.currentThread().getName() + "线程读取ok");
    }
}

运行结果会出现问题，还没等线程写完或读完，就被其他线程写入，

如何解决这样的问题，需要加锁

之前我们使用的 Lock 锁，但粒度比较粗，只是普通的锁，

这里我们加读写锁，ReadWriteLock，这是一个更加细粒度的锁

public class ReadWriteLockDemo {
     
    public static void main(String[] args) {
     
        // 线程操作资源类
        MyCache myCache = new MyCache();
        int num = 6;
        for (int i = 1; i < num; i++) {
     
            int finalI = i;
            new Thread(()->{
     
                myCache.write(String.valueOf(finalI), String.valueOf(finalI));
            },String.valueOf(i)).start();
        }
        for (int i = 1; i < num; i++) {
     
            int finalI = i;
            new Thread(()->{
     
                myCache.read(String.valueOf(finalI));
            },String.valueOf(i)).start();
        }
    }
}
// 自定义缓存
class MyCache{
     
    private volatile Map<String,String> map = new HashMap<>();
    private ReadWriteLock readWriteLock= new ReentrantReadWriteLock();
    // 存，写,写入的时候只希望只有一个线程在写
    public void write(String key, String value) {
     
        readWriteLock.writeLock().lock();
        try {
     
            System.out.println(Thread.currentThread().getName() + "线程开始写入");
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + "线程开始写入ok");
        } catch (Exception e) {
     
            e.printStackTrace();
        } finally {
     
            readWriteLock.writeLock().unlock();
        }
    }
    // 取，读,所有线程都可以读
    public void read(String key) {
     
        readWriteLock.readLock().lock();
        try {
     
            System.out.println(Thread.currentThread().getName() + "线程开始读取");
            map.get(key);
            System.out.println(Thread.currentThread().getName() + "线程读取ok");
        } catch (Exception e) {
     
            e.printStackTrace();
        } finally {
     
            readWriteLock.readLock().unlock();
        }
    }
}

运行可以发现，写入时不可以被插队，读取时可以被多人执行

小结：

读-读可以共存
读-写不能共存
写-写不能共存

也可以这样称呼，含义都是一样，名字不同而已

独占锁（写锁）一次只能由一个线程占有
享锁（读锁）一次可以有多个线程占有

10.阻塞队列

阻塞队列

Blockqueue

阻塞队列 BlockQueue 是Collection 的一个子类

应用场景：多线程并发处理、线程池

BlockingQueue 有四组 API

方式	抛出异常	不会抛出异常,有返回值	阻塞等待	超时等待
添加操作	add()	offer() 供应	put()	offer(obj,int,timeunit.status)可设置时间
移除操作	remove()	poll() 获得	take()	poll(int,timeunit.status)可设置时间
判断队列首部	element()	peek() 偷看,偷窥

代码演示：四种情况

public class BlockingQueueDemo {
     
    // 抛异常 add remove
    @Test
    public void test01(){
     
        ArrayBlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);
        System.out.println(blockingQueue.add("a"));
        System.out.println(blockingQueue.add("b"));
        System.out.println(blockingQueue.add("c"));
        // 查看队首
        System.out.println(blockingQueue.element());
        // 如果再添加就会抛出异常 java.lang.IllegalStateException: Queue full
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        // 如果再移除也会造成 java.util.NoSuchElementException
    }

    // 不抛出异常，offer、poll、peek
    @Test
    public void test02(){
     
        ArrayBlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);
        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("b"));
        System.out.println(blockingQueue.offer("c"));
        // 再添加不会抛出异常，而是返回false
        System.out.println(blockingQueue.offer("d"));
        // 检测队首元素
        System.out.println(blockingQueue.peek());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        // 再移除不会抛出异常，而是返回null
        System.out.println(blockingQueue.poll());
    }

    // 如果队列满了，等待,一直阻塞
    @Test
    public void test03() throws InterruptedException {
     
        ArrayBlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);
        // 一直阻塞，不会返回值
        blockingQueue.put("a");
        blockingQueue.put("b");
        blockingQueue.put("c");
        // 队列已满，再添加，则阻塞等待添加,程序一直在阻塞中，不结束
        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());
        // 如果再移除不会抛出异常，但是会一直阻塞在这里了
    }
    // 这种情况也会发生阻塞等待，但会有超时结束
    @Test
    public void test04() throws InterruptedException {
     
        ArrayBlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);
        blockingQueue.offer("a");
        blockingQueue.offer("b");
        blockingQueue.offer("c");
        System.out.println("开始等待");
        blockingQueue.offer("d",2, TimeUnit.SECONDS);
        System.out.println("等待结束");
        System.out.println("=================取值=====================");
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println("取值开始等待");
        blockingQueue.poll(2,TimeUnit.SECONDS);//超过两秒，我们就不等待了
        System.out.println("取值结束等待");
    }
}

SynchronizedQueue 同步队列

同步队列没有容量，进去一个元素，必须等待取出来之后，才能再往里面放一个元素

SynchronizedQueue 使用 put 方法和 take 方法
Synchronized 和其他的 BlockingQueue 不一样它不存储元素；
put了一个元素，就必须从里面先 take 出来，否则不能再 put 进去值！
并且 SynchronousQueue 的 take 是使用了 lock 锁保证线程安全的。

public class SynchronousQueueDemo {
     
    public static void main(String[] args) {
     
        BlockingQueue<String> synchronousQueue = new SynchronousQueue<>();
        new Thread(()->{
     
            try {
     
                System.out.println(Thread.currentThread().getName()+"put 01");
                synchronousQueue.put("1");
                System.out.println(Thread.currentThread().getName()+"put 02");
                synchronousQueue.put("2");
                System.out.println(Thread.currentThread().getName()+"put 03");
                synchronousQueue.put("3");
            } catch (InterruptedException e) {
     
                e.printStackTrace();
            }
        }).start();
        new Thread(()->{
     
            try {
     
                System.out.println(Thread.currentThread().getName()+"take"+synchronousQueue.take());
                System.out.println(Thread.currentThread().getName()+"take"+synchronousQueue.take());
                System.out.println(Thread.currentThread().getName()+"take"+synchronousQueue.take());
            } catch (InterruptedException e) {
     
                e.printStackTrace();
            }
        }).start();
    }
}

运行发现，两个线程一个存，一个取，即使我们没有规定顺序，执行起来也是存一次取一次，交替执行，这是 SynchronousQueue 的特性决定的

结论：put进入一个元素，必须先取出来，否则不能再put

11.线程池（重点）

池化技术

线程池重点：三大方式、七大参数、四种拒绝策略

程序的运行的本质：占用系统的资源 ! 优化CPU资源的使用 ===>池化技术（线程池、连接池、内存池、对象池…）

池化技术：实现准备好一些资源，有人要用，就来我这里拿，用完之后还给我

线程池的好处:

降低资源消耗
提高响应速度
方便管理

如何优化：

线程复用,可以控制最大并发数,管理线程

线程池：三大方法

查看阿里巴巴开发手册

ExecutorService threadPool = Executors.newSingleThreadExecutor();//单个线程
ExecutorService threadPool2 = Executors.newFixedThreadPool(5); //创建一个固定的线程池的大小
ExecutorService threadPool3 = Executors.newCachedThreadPool(); //可伸缩的

之前我们所学知识，直接创建线程，现在我们通过线程池来创建线程，使用池化技术

代码演示

//Executors 工具类
//使用了线程池之后要使用线程池创建线程
public class Demo01 {
     
    public static void main(String[] args) {
     
        // ExecutorService service = Executors.newSingleThreadExecutor();//单个线程
        // ExecutorService service = Executors.newFixedThreadPool(5);//创建一个固定的线程池的大小
        ExecutorService service = Executors.newCachedThreadPool();//可伸缩的，遇强则强，遇弱则弱
        try {
     
            for (int i = 0; i < 10; i++) {
     
                service.execute(() -> {
     
                    System.out.println(Thread.currentThread().getName() + "ok");
                });
            }
            //线程池用完要关闭线程池
        } finally {
     
            service.shutdown();
        }
    }
}

通过测试我们发现，固定线程池的方式至多只能创建固定数量，可伸缩的方式就会视情况而定

固定线程池（循环次数10）

可伸缩线程池，（循环次数100），

出现了 30多个线程

线程池：七大参数

源码分析：

newSingleThreadExecutor

public static ExecutorService newSingleThreadExecutor() {
     
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}

newFixedThreadPool

public static ExecutorService newFixedThreadPool(int nThreads) {
     
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

newCachedThreadPool

public static ExecutorService newCachedThreadPool() {
     
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

结论：所有线程池最终都调用的 ThreadPoolExecutor

查看源码，有七个参数

public ThreadPoolExecutor(int corePoolSize, //核心线程池大小
                          int maximumPoolSize,	//最大核心线程池大小
                          long keepAliveTime,	//存活时间，超时了没有调用就会释放
                          TimeUnit unit,	// 超时单位
                          BlockingQueue<Runnable> workQueue,  //阻塞队列
                          ThreadFactory threadFactory,//线程工厂,创建线程的,一般不动
                          RejectedExecutionHandler handler) {
     //拒绝策略
    if (corePoolSize < 0 ||
        maximumPoolSize <= 0 ||
        maximumPoolSize < corePoolSize ||
        keepAliveTime < 0)
        throw new IllegalArgumentException();
    if (workQueue == null || threadFactory == null || handler == null)
        throw new NullPointerException();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

通过观察，上面的三种创建方式其实就是换了不同的参数

分析参数，才会有阿里巴巴规范所说的，不允许使用 Executors 创建线程池，而是通过 ThreadPoolExecutor 创建，因为参数可控

从这张图片来分析

客户来银行办业务，一开始银行不会开放全部窗口，只开一部分（1.2），对应了core；
随着人逐渐增多，等候的人呆在了候客区，也就是阻塞队列；
人数进一步增多，开始开放其他窗口（3.4.5），用于营业，银行最大数量对应了 max；
银行已经达到最大接客数量，再有客户进来，银行选择了拒绝策略；

理解了以上理论，我们将按照阿里巴巴手册的规范，手动创建线程池，改造代码

//自定义线程池，创建默认的线程工厂
ExecutorService threadPool = new ThreadPoolExecutor(
        3, // 核心线程池大小,也是初始默认大小
        5, // 最大并发数
        10, // 超时时间，超过时间没有业务就会释放多余的线程回到默认数量
        TimeUnit.SECONDS, // 时间单位
        new LinkedBlockingQueue<>(3),// 线程等候队列，这里表示队列超过3个等待就会触发最大线程数
        Executors.defaultThreadFactory(), //线程创建工厂
        new ThreadPoolExecutor.AbortPolicy());//拒绝策略，有四种拒绝策略，这个是默认的，表示如果队列满了就不再处理，并抛出异常

四种拒绝策略

new ThreadPoolExecutor.AbortPolicy: // 拒绝策略含义：银行满了，还有人进来，不处理这个人的，并抛出异常
new ThreadPoolExecutor.CallerRunsPolicy(): // 拒绝策略含义：哪来的去哪里，这里就是回到main线程进行处理
new ThreadPoolExecutor.DiscardPolicy(): // 拒绝策略含义：如果队列满了，丢掉任务，不会抛出异常。
new ThreadPoolExecutor.DiscardOldestPolicy()： // 拒绝策略含义：如果队列满了，尝试去和最早的进程竞争，成功则执行，失败则丢掉，也不会抛出异常
这里的四大拒绝策略其实也对应了 BlockingQueue 四组 API 中抛异常策略

分析：

线程池最大承载数 = 线程最大并发数 + 队列最大数，在这里就是 5+3=8
超过最大承载数量就会触发拒绝策略

如何设置线程池的最大值（maximumPoolSize）

两种方案：

CPU密集型：CPU有几核，maximumPoolSize就是几，可以保证CPU的效率最高
IO 密集型：找出当前程序中十分耗 I/O 的线程数量，maximumPoolSize大于这个数的两倍即可

12.四大函数式接口（重点）

新时代程序员（JDK8新特性）：lambda 表达式、链式编程、函数式接口、Stream 流式计算

函数式接口：只有一个方法的接口，比如 Runnable 接口

优点：简化编程，在新版本的框架底层大量使用

剩下的都是一些复合类型

Function 函数型接口

传入参数T，返回类型R

代码演示

public class FunctionDemo {
     
    public static void main(String[] args) {
     
        Function<String,String> function = (str)->{
     
            return str;
        };
        System.out.println(function.apply("aaaaaaa"));
    }
}

测试效果，传入什么，返回什么，像是一个工具类

Predicate 断定型接口

只能传入一个参数，返回值是 boolean

代码演示

public class PredicateDemo {
     
    public static void main(String[] args) {
     
        Predicate<String> predicate = (str)->{
     
            return str.isEmpty();
        };
        System.out.println(predicate.test("aaa"));
        System.out.println(predicate.test(""));
    }
}

测试效果，我们可以利用这一特性，对传入的参数进行判断，返回 true or false，

这里就是判断输入字符串是否为空

Suppier 供给型接口

没有输入，只有返回值，输出

代码演示

public class SupplierDemo {
     
    public static void main(String[] args) {
     
        Supplier<String> supplier = ()->{
     
            return "1024";
        };
        System.out.println(supplier.get());
    }
}

测试效果，这个实例展示输出的返回值

Consummer 消费型接口

只输入，没有返回值

代码演示

public class ConsumerDemo {
     
    public static void main(String[] args) {
     
        Consumer<String> consumer = (str)->{
     
            System.out.println(str);
        };
        consumer.accept("abc");
    }
}

测试结果，这里我们实例就是打印一下消费了什么内容

小结：函数式接口的作用

简化编程模型

这里的接口只是起一个规范，具体怎么来编写业务代码，需要我们自己重写里面的方法

13.Stream 流式计算

大数据：存储+计算

集合、MySQL 本质就是存储数据，而计算应该交给流来操作

首先查看 package java.util.stream包下的 interface Stream 接口

可以看到，Stream 中的大量方法都是用了函数式接口

题目要求：

ID必须是偶数
年龄必须大于23岁
用户名转为大写字母
用户名倒着排序
只输出一个用户

根据上述需求，编写演示代码

public class StreamDemo {
     
    public static void main(String[] args) {
     
        User user1 = new User(1, "a", 21);
        User user2 = new User(2, "b", 22);
        User user3 = new User(3, "c", 23);
        User user4 = new User(4, "d", 24);
        User user5 = new User(5, "e", 25);
        // 集合用于存储
        List<User> list = Arrays.asList(user1, user2, user3, user4, user5);
        // 计算交给Stream流
        // 一行代码使用了 lambda表达式  链式编程  函数式接口  Stream流式计算
        list.stream()
                .filter(user -> {
      return user.getId() % 2 == 0;})
                .filter(user -> {
      return user.getAge() > 23;})
                .map(user -> {
      return user.getName().toUpperCase();})
                .sorted((u1,u2)->{
      return u2.compareTo(u1);})
                .limit(1)
                .forEach(System.out::println);
    }
}

执行效果，最终筛选出 D

理解分析：

Collection有一个方法 stream() 可以返回 Stream 流，然后我们使用 Stream 调用接口里的方法开启流式计算
理解这些方法需要我们首先理解函数式接口，然后对照 API 查看各个方法的含义

比如，第一个方法 filter

这个方法的参数需要我们使用 Predicate 断定型接口的实例，因此我们重写这个接口方法并使用了 lambda 表达式

user -> {
     return user.getId() % 2 == 0;}

流中的所有user只有满足ID为偶数的才会返回true，通过筛选，filter返回的流中只有ID为偶数的user
这里的流在计算判断时，会将所有的user全部都过一遍，然后按照我们的业务规则进行筛选
这些代码就是通过泛型统一的元素类型为 User

总结一下：

list转为流，流调用方法，方法里的参数用函数式接口，函数式接口有我们定义业务规则，然后方法返回的就是符合条件的元素构成的流，继续链式编程

这种方式不仅简化代码，底层优化也使得代码效率得到提高，是不是感觉很强大！

14.ForkJoin 分之合并

ForkJoin 在JDK1.7，并行执行任务！提高效率~。在大数据量速率会更快！

大数据中：MapReduce 核心思想->把大任务拆分为小任务！

ForkJoin 特点：工作窃取

实现原理：双端队列！从上面和下面都可以去拿到任务进行执行！

如何使用ForkJoin

用法

使用要点：

通过 ForkJoinPool 来执行，把 ForkJoinTask 作为参数丢进去
计算任务 execute（ForkJoinTask task）（execute是同步执行，submit是异步执行）
写一个计算类要去继承 RecursiveTask（底层还是ForkJoinTask），重写方法，定义计算规则

准备计算类

public class ForkJoinDemo extends RecursiveTask<Long> {
     
    private long start;     // 1
    private long end;       // 20_0000_0000
    private long temp = 1_0000L;
    public ForkJoinDemo(long start, long end) {
     
        this.start = start;
        this.end = end;
    }
    // 实现抽象类需要重写计算方法
    @Override
    protected Long compute() {
     
        // 小于临界值则直接求和
        if (end - start < temp) {
     
            Long sum = 0L;
            for (Long i = start; i < end; i++) {
     
                sum += i;
            }
            return sum;
        } else {
     
            // 大于临界值则采用分支合并计算
            long middle = (end + start) / 2;  //中间值
            ForkJoinDemo task1 = new ForkJoinDemo(start, middle);
            task1.fork(); // 拆分任务,把任务压入线程队列
            ForkJoinDemo task2 = new ForkJoinDemo(middle + 1, end);
            task2.fork();// 拆分任务,把任务压入线程队列
            return task1.join() + task2.join();
        }
    }
}

写测试类

public class ForkJoinTest {
     
    private static final long SUM = 20_0000_0000;
    public static void main(String[] args) throws ExecutionException, InterruptedException {
     
        test1();
        test2();
        test3();
    }
    // 使用普通方法
    public static void test1(){
     
        long star = System.currentTimeMillis();
        long sum = 0L;
        for (int i = 0; i < SUM; i++) {
     
            sum+=i;
        }
        long end = System.currentTimeMillis();
        System.out.println(sum);
        System.out.println("时间：" + (end-star));
        System.out.println("---------------");
    }
    // 使用 ForkJoin 方法
    public static void test2() throws ExecutionException, InterruptedException {
     
        long star = System.currentTimeMillis();
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Long> task = new ForkJoinDemo(0L,SUM);
        ForkJoinTask<Long> submit = forkJoinPool.submit(task);
        Long along = submit.get();
        System.out.println(along);
        long end = System.currentTimeMillis();
        System.out.println("时间：" + (end - star));
        System.out.println("---------------");
    }
    // 使用流计算
    public static void test3(){
     
        long star = System.currentTimeMillis();
        long sum = LongStream.range(0L,20_0000_0000L).parallel().reduce(0,Long::sum);
        System.out.println(sum);
        long end = System.currentTimeMillis();
        System.out.println("时间：" + (end - star));
        System.out.println("-------------");
    }
}

运行测试

流式计算的效率最高，

为什么我的 forkjoin 计算比普通计算时间更长？？？

分析：

使用 forkjoin 进行计算时，底层会自动调用 compute 方法计算，并使用我们重写的计算规则来判断
比如本例子，当compute发现数值较大需要拆分，则拆分任务并压入线程队列
然后再compute，如果发现仍然需要拆分，则再次拆分压入队列，直到不用再拆分才开始将当前队列开始计算
new ForkJoinDemo 中再次 new ForkJoinDemo 这本质上也是递归操作

注意：compute是 forkjoin 计算时底层自己调用的，这也是为什么很多人不理解他是递归的原因，我们查看源码

进入get

进入 getRawResult

选择实现类

可以看到最终结果就是由底层 compute得来的

15.异步回调

Future 设计的初衷: 对将来的某个事件的结果进行建模

Java也可以实现异步调用，与ajax是一个道理

我们平时都使用 CompletableFuture

没有返回值的runAsync异步回调

public class CompletableFutureDemo {
     
    public static void main(String[] args) throws ExecutionException, InterruptedException {
     
//        发起一个请求
        System.out.println(System.currentTimeMillis());
        System.out.println("-----------");
        
        CompletableFuture<Void> future = CompletableFuture.runAsync(()->{
     
//            发起一个异步任务
            try {
     
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
     
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"......");
        });
        
        System.out.println(System.currentTimeMillis());
        System.out.println("-------------------------");
        System.out.println(future.get());//获取执行结果
    }
}

有返回值的异步回调supplyAsync

public class CompletableFutureDemo {
     
    public static void main(String[] args) throws ExecutionException, InterruptedException {
     
//        发起一个请求
        System.out.println(System.currentTimeMillis());
        System.out.println("-----------");

        CompletableFuture<Void> future = CompletableFuture.runAsync(()->{
     
//            发起一个异步任务
            try {
     
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
     
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"......");
        });

        System.out.println(System.currentTimeMillis());
        System.out.println("-------------------------");
        System.out.println(future.get());//获取执行结果
    }
    @Test
    public void test02() throws ExecutionException, InterruptedException {
     
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(()->{
     
            System.out.println(Thread.currentThread().getName());
            try {
     
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
     
                e.printStackTrace();
            }
            return 1024;
        });
        System.out.println(completableFuture.whenComplete((t,u)->{
     
//            success 回调
            System.out.println("t=>" +t);//正常的返回结果
            System.out.println("u=>" +u);//抛出异常的错误信息
        }).exceptionally((e)->{
     
//            error 回调
            System.out.println(e.getMessage());
            return 404;
        }).get());
    }
}

whenComplete: 有两个参数，一个是t 一个是u

T：是代表的正常返回的结果；

U：是代表的抛出异常的错误信息；

如果发生了异常，get可以获取到exceptionally返回的值；

16.JMM

谈谈对 Volatile 的理解

Volate是Java虚拟机提供轻量级的同步机制

保证可见性
不保证原子性
禁止指令重排

什么是 JMM

JMM: JAVA 内存模型，不存在的东西，是一个概念，也是一个约定！

关于JMM的一些同步的约定：

线程解锁前，必须把共享变量立刻刷回主存；
线程加锁前，必须读取主存中的最新值到工作内存中；
加锁和解锁是同一把锁；

线程中分为工作内存、主内存

JMM约定有八种操作:

Read（读取）：作用于主内存变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用；
load（载入）：作用于工作内存的变量，它把read操作从主存中变量放入工作内存中；
Use（使用）：作用于工作内存中的变量，它把工作内存中的变量传输给执行引擎，每当虚拟机遇到一个需要使用到变量的值，就会使用到这个指令；
assign（赋值）：作用于工作内存中的变量，它把一个从执行引擎中接受到的值放入工作内存的变量副本中；
store（存储）：作用于主内存中的变量，它把一个从工作内存中一个变量的值传送到主内存中，以便后续的write使用；
write（写入）：作用于主内存中的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中；
lock（锁定）：作用于主内存的变量，把一个变量标识为线程独占状态；
unlock（解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定；

问题来了，b刷新了主内存，a没有及时发现

因此，JMM规定了八个规定

不允许read和load、store和write操作之一单独出现。即使用了read必须load，使用了store必须write
不允许线程丢弃他最近的assign操作，即工作变量的数据改变了之后，必须告知主存
不允许一个线程将没有assign的数据从工作内存同步回主内存
一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是对变量实施use、store操作之前，必须经过assign和load操作
一个变量同一时间只有一个线程能对其进行lock。多次lock后，必须执行相同次数的unlock才能解锁
如果对一个变量进行lock操作，会清空所有工作内存中此变量的值，在执行引擎使用这个变量前，必须重新load或assign操作初始化变量的值
如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量
对一个变量进行unlock操作之前，必须把此变量同步回主内存

17.Volatile

了解 JMM 八种操作和八个规定，我们开始理解 Volatile，也就是Java虚拟机提供轻量级的同步机制

保证可见性

public class VolatileDemo {
     
    // 如果不加 volatile 程序会死循环
    // 加了volatile 是可以保证可见性的
    private volatile static Integer number = 0;
    public static void main(String[] args) {
     // main 线程
        // 子线程1
        new Thread(()->{
     
            while (number==0){
     }
        }).start();
        try {
     
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }
        number = 1;
        System.out.println(number);
    }
}

测试运行

加了volatile 是可以保证可见性的

如果将 volatile 去掉，主线程将number修改为1，子线程不知道，还在按照 number=0一直做死循环

不保证原子性

原子性：不可分割；

线程A在执行任务的时候，不能被打扰的，也不能被分割的，要么同时成功，要么同时失败。

代码举例

public class VDemo02 {
     
    private static int number = 0;
    public static void add(){
     
        number++;
        // ++ 不是一个原子操作，是2~3个操作
    }
    public static void main(String[] args) {
     
        // 理论上 number === 20000
        for (int i = 1; i <= 20; i++) {
     
            new Thread(()->{
     
                for (int j = 1; j <= 1000 ; j++) {
     
                    add();
                }
            }).start();
        }
        // java 默认有两个线程 main 和 gc  超过2个说明还有其他线程存活
        // 这里的含义就是 如果main和gc之外还有其他线程，主线程就会礼让，保证其他线程执行完
        while(Thread.activeCount()>2){
     
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+",num + "+number);
    }
}

运行测试，理论上number应该为20000，实际上达不到，因为number++不是原子操作，存在并发问题

解决办法之一就是给 add 加锁

public synchronized static void add(){
     
number++;
}

去掉synchronized ，给 number 加 volatile

private volatile static int number = 0;

运行测试，发现总数达不到20000，说明 volatile不能保证原子性

问题：

如果不加 lock 和 synchronized，如何保证原子性？

首先分析 number++的底层实现

通过命令行进入到class文件所在目录，执行指令，查看他的字节码指令逻辑

javap -c VDemo02.class

说明 number++ 在底层有多步骤实现

回到这个问题，如果不加 lock 和 synchronized，如何保证原子性

使用原子类解决原子性问题

使用原子类定义 number，修改 number++

public class VDemo02 {
     
    // private volatile static int number = 0;
    private static volatile AtomicInteger number = new AtomicInteger();
    public static void add(){
     
        // number++;
        // ++ 不是一个原子操作，是2~3个操作
        number.incrementAndGet();//底层是 CAS 保证原子性
    }
    public static void main(String[] args) {
     
        // 理论上 number === 20000
        for (int i = 1; i <= 20; i++) {
     
            new Thread(()->{
     
                for (int j = 1; j <= 1000 ; j++) {
     
                    add();
                }
            }).start();
        }
        // java 默认有两个线程 main 和 gc  超过2个说明还有其他线程存活
        // 这里的含义就是 如果main和gc之外还有其他线程，主线程就会礼让，保证其他线程执行完
        while(Thread.activeCount()>2){
     
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+",num + "+number);
    }
}

为什么能保证原子性，进入源码查看，

为什么要使用原子类？

因为他比锁要高效很多

这些类的底层都直接和操作系统挂钩！是在内存中修改值。Unsafe 类是一个很特殊的存在；

禁止指令重排

什么是指令重排？

我们写的程序，计算机并不是按照我们自己写的那样去执行的

源代码–>编译器优化重排–>指令并行也可能会重排–>内存系统也会重排–>执行

int x=1; //1
int y=2; //2
x=x+5;   //3
y=x*x;   //4

//我们期望的执行顺序是 1_2_3_4  可能执行的顺序会变成2134 1324
//可不可能是 4123？ 不可能的

因为，处理器在进行指令重排的时候，会考虑数据之间的依赖性！

这个例子是指令重排没有造成影响，也有造成影响的时候

比如，假设abxy默认都是0，执行以下线程操作

线程A	线程B
x = a	y = b
b = 1	a = 2

正常的结果应该是 x = 0; y =0;

然而可能会出现以下的执行顺序

线程A	线程B
b=1	a=2
x=a	y=b

可能在线程A中会出现，先执行b=1,然后再执行x=a；

在B线程中可能会出现，先执行a=2，然后执行y=b；

那么就有可能结果如下：x=2; y=1.

这种情况可能很难出现，但是还是有一定概率，需要注意

volatile可以避免指令重排：

volatile中会加一道内存的屏障，这个内存屏障可以保证在这个屏障中的指令顺序

内存屏障：CPU指令。作用：

1、保证特定的操作的执行顺序；

2、可以保证某些变量的内存可见性（利用这些特性，就可以保证volatile实现的可见性）

小结

volatile 可以保证可见性
不能保证原子性
由于内存屏障，可以保证避免指令重排的现象产生
面试官：那么你知道在哪里用这个内存屏障用得最多呢？单例模式

18.玩转单例模式

饿汉模式

public class SingleHungryDemo {
     
    /*
    * 可能会浪费空间
    * */
    private byte[] data1 = new byte[1024*1024];
    private byte[] data2 = new byte[1024*1024];
    private byte[] data3 = new byte[1024*1024];
    private byte[] data4 = new byte[1024*1024];
    
    private SingleHungryDemo(){
     
        
    }
    private final static SingleHungryDemo hungry = new SingleHungryDemo();
    public static SingleHungryDemo getInstance(){
     
        return hungry;
    }
}

程序一加载就可能占用大量资源

懒汉模式

// 懒汉式单例，单线程安全
public class LazyMan {
     
    // 构造器私有
    private LazyMan() {
     
        System.out.println(Thread.currentThread().getName() + "ok");
    }
    private static LazyMan lazyMan;
    public static LazyMan getInstance(){
     
        if(lazyMan == null){
     
            lazyMan = new LazyMan();
        }
        return lazyMan;
    }
    // 多线程会出现并发问题
    public static void main(String[] args) {
     
        for (int i= 0;i<10;i++) {
     
            new Thread(()->{
     
                LazyMan.getInstance();
            }).start();
        }
    }
}

但是多线程下有并发问题，这里仍然出现了多个线程，本应该只有一个

DCL 懒汉式

因此我们需要加锁

// 懒汉式单例
public class LazyMan {
     
    // 构造器私有
    private LazyMan() {
     
        System.out.println(Thread.currentThread().getName() + "ok");
    }
    private static LazyMan lazyMan;
    // 双重检测模式 简称 DCL
    public static LazyMan getInstance() {
     
        if (lazyMan == null) {
     
            synchronized (LazyMan.class) {
     
                if (lazyMan == null) {
     
                    lazyMan = new LazyMan();
                }
            }
        }
        return lazyMan;
    }
    // 多线程会出现并发问题
    public static void main(String[] args) {
     
        for (int i= 0;i<10;i++) {
     
            new Thread(()->{
     
                LazyMan.getInstance();
            }).start();
        }
    }
}

但是 DCL 懒汉式仍然有问题，极端情况下会出现问题

lazyMan = new LazyMan(); 不是原子性操作，里面会经历三步操作

分配内存空间
2.执行构造方法，初始化对象
把这个对象指向这个空间

这就有可能出现指令重排问题

比如执行的顺序是 1 3 2 等
另一个线程也可能会干扰这个线程，导致比如返回的 lazyman为空

为了安全，我们要避免指令重排，我们就可以添加 volatile 保证指令重排问题

静态内部类实现单例

// 静态内部类实现单例
public class Holder {
     
    // 单例模式一定是构造器私有
    private Holder() {
     

    }
    public static Holder getInstance() {
     
        return InnerClass.HOLDER;
    }
    public static class InnerClass {
     
        private static final Holder HOLDER = new Holder();
    }
}

反射可以破坏单例

但是目前，单例仍然不安全，因为可以使用反射

// 懒汉式单例
public class LazyMan {
     
    // 构造器私有
    private LazyMan() {
     
        System.out.println(Thread.currentThread().getName() + "ok");
    }
    private static LazyMan lazyMan;
    // 双重检测模式 简称 DCL
    public static LazyMan getInstance() {
     
        if (lazyMan == null) {
     
            synchronized (LazyMan.class) {
     
                if (lazyMan == null) {
     
                    lazyMan = new LazyMan();
                }
            }
        }
        return lazyMan;
    }
    // 反射
    public static void main(String[] args) throws Exception {
     
        LazyMan instance = LazyMan.getInstance();
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);// 无视私有构造器
        LazyMan instance2 = declaredConstructor.newInstance();

        System.out.println(instance);
        System.out.println(instance2);
    }
}

运行发现，两个对象不一样，不是单例

如何解决这种问题？我们可以在构造器中加锁判断，防止别人使用反射破坏单例

// 构造器私有
    private LazyMan() {
     
         synchronized (LazyMan.class) {
     
             if (lazyMan != null) {
     
                 throw new RuntimeException("不要试图使用反射破坏异常");
             }
         }
        System.out.println(Thread.currentThread().getName() + "ok");
    }

但是，如果两个instance都是通过反射创建的，如何判断呢？

LazyMan instance1 = declaredConstructor.newInstance();
LazyMan instance2 = declaredConstructor.newInstance();

我们可以设置一个标志位，来判断对象是否已经被创建了无需再创建，

添加标志位，将构造器改造为

private static boolean swy = false;
    // 构造器私有
    private LazyMan() {
     
         synchronized (LazyMan.class) {
     
             if (swy == false) {
     
                 swy = true;
             } else {
     
                 throw new RuntimeException("不要试图使用反射破坏异常");
             }
         }
        System.out.println(Thread.currentThread().getName() + "ok");
    }

只要构造器被调用，表示位就会变化，然后无法再次创建对象，

除非对方有反编译器看到了标志位，否则仅仅使用反射也不能创建多例，标志也可以再进一步加密，进一步提高了安全性

假设对手更高级，找到了标志位，并通过反射将标志位破坏了

	// 反射
    public static void main(String[] args) throws Exception {
     
        Field swy = LazyMan.class.getDeclaredField("swy");
        swy.setAccessible(true);

        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);// 无视私有构造器
        LazyMan instance = declaredConstructor.newInstance();
        // 通过反射破坏标志位
        swy.set(instance, false);
        
        LazyMan instance2 = declaredConstructor.newInstance();

        System.out.println(instance);
        System.out.println(instance2);
    }

这样就又一次破坏了单例

最终得出结论：道高一尺，魔高一丈

都是反射惹的祸，这就需要引入枚举

枚举

反射不能破坏枚举

// 枚举本身是一个类，JDK1.5出现
public enum  EnumSingle {
     
    INSTANCE;
    public EnumSingle getInstance() {
     
        return INSTANCE;
    }
}
class Test {
     
    public static void main(String[] args) {
     
        EnumSingle instance1 = EnumSingle.INSTANCE;
        EnumSingle instance2 = EnumSingle.INSTANCE;
        System.out.println(instance1);
        System.out.println(instance2);
    }
}

如果还是要用反射操作呢？

查看target目录中 EnumSingle 编译后的 class 代码

发现有无参构造，因此我们尝试再次使用反射

// 枚举本身是一个类，JDK1.5出现
public enum  EnumSingle {
     
    INSTANCE;
    public EnumSingle getInstance() {
     
        return INSTANCE;
    }
}
class Test {
     
    public static void main(String[] args) throws Exception {
     
        EnumSingle instance1 = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);// 破除私有
        EnumSingle instance2 = declaredConstructor.newInstance();// 反射创建对象
        System.out.println(instance1);
        System.out.println(instance2);
    }
}

运行结果报异常

异常的含义是，我们的枚举类中没有空参数构造器

但是我们在IDEA中查看 EnumSingle.class 显示有无参构造，为什么？

我们使用命令行反编译查看一下，还是无参构造，还是有问题，这个代码也欺骗了我们，因为异常枚举类没有无空参构造

我们使用反编译神器 jad.exe

链接：https://pan.baidu.com/s/155pwsY7F4cLnN4KUxhK-ag

提取码：ztyp

把它复制到，class文件所在目录，在这个目录下执行命令行jad -sjava EnumSingle.class，把它反编译成Java文件

打开这个Java文件，得到枚举类型的最终反编译源码

package com.swy.single;


public final class EnumSingle extends Enum
{
     

    public static EnumSingle[] values()
    {
     
        return (EnumSingle[])$VALUES.clone();
    }

    public static EnumSingle valueOf(String name)
    {
     
        return (EnumSingle)Enum.valueOf(com/swy/single/EnumSingle, name);
    }

    private EnumSingle(String s, int i)
    {
     
        super(s, i);
    }

    public EnumSingle getInstance()
    {
     
        return INSTANCE;
    }

    public static final EnumSingle INSTANCE;
    private static final EnumSingle $VALUES[];

    static 
    {
     
        INSTANCE = new EnumSingle("INSTANCE", 0);
        $VALUES = (new EnumSingle[] {
     
            INSTANCE
        });
    }
}

发现这里使用了一个有参构造器

private EnumSingle(String s, int i)
    {
     
        super(s, i);
    }

所以我们再次改造上面的反射创建枚举对象的代码

class Test {
     
    public static void main(String[] args) throws Exception {
     
        EnumSingle instance1 = EnumSingle.INSTANCE;
        // 通过反编译器发现，枚举使用的是有参构造
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);// 破除私有
        EnumSingle instance2 = declaredConstructor.newInstance();// 反射创建对象
        System.out.println(instance1);
        System.out.println(instance2);
    }
}

运行测试，终于得到我们想要的结果
枚举不能通过反射创造对象，所以，枚举不能被反射破坏单例

19.深入理解CAS

为什么深入理解CAS？大厂必须深入研究底层！！！！修内功！操作系统、计算机网络原理、组成原理、数据结构

什么是CAS

CAS：compareAndSet 比较并交换

传统原子类

public class CASDemo {
     
    // CAS: compareAndSet 比较并交换
    public static void main(String[] args){
     
        AtomicInteger atomicInteger = new AtomicInteger(2020);

        // boolean compareAndSet(int expect, int update)
        // 第一个参数：期望值，第二个参数：更新值
        // 如果实际值 和 我期望值相同，那么就更新
        // 如果实际制 和 我期望值不同，那么就不更新
        System.out.println(atomicInteger.compareAndSet(2020,2021));
        System.out.println(atomicInteger.get());

        // 因为期望值是 2020 ，实际值却变成了2021 所以会修改失败
        // CAS 是 CPU 的并发原语
        atomicInteger.getAndIncrement();//++操作
        System.out.println(atomicInteger.compareAndSet(2020,2021));
        System.out.println(atomicInteger.get());
    }
}

CAS 是 CPU 的并发原语，意思就是CPU的指令

进入 getAndIncrement 查看

进入 unsafe

Unsafe 是什么？

Java无法操作内存
Java可以调用C++ 的本地方法 native，操作内存
Unsafe 就相当于Java 的后门，通过这个类的方法来操作内存

valueOffset：内存地址的偏移值，而且value也被volatile修饰，保证不被指令重排

Unsafe 类提供的都是本地方法（native），包括上面的 getAndAddInt（+1的操作）

这个的方法的含义：如果var1这个对象，对应的值var2，是var5，那么就给var5+var4

这是一个内存操作，效率很高

Java 的 CAS 底层就是上述这个CAS，

do {
     
    var5 = this.getIntVolatile(var1, var2);
} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

这段代码本身也是一个自旋锁

小结

CAS：

比较当前工作内存中的值和主内存中的值，如果这个值是期望的，那么则执行操作！如果不是就一直循环，使用的是自旋锁。

CAS 缺点：

循环会耗时；(即使这样，也比Java操作好)
一次性只能保证一个共享变量的原子性；
它会存在ABA问题

ABA 问题

了解到CAS，就一定要知道 ABA 问题
一句话解释：狸猫换太子

解释一下：

A 期望这是一块蛋糕，如果是，A就进行更新值，这是线程B来操作了蛋糕，换成了蛋糕，然后又换回蛋糕，这个过程A是不知道的，A继续操作这个蛋糕，并且认为这还是以前的蛋糕

看代码演示

public class CASDemo {
     
    // CAS: compareAndSet 比较并交换
    public static void main(String[] args){
     
        AtomicInteger atomicInteger = new AtomicInteger(2020);
        
        // 捣乱的线程
        System.out.println(atomicInteger.compareAndSet(2020,2021));
        System.out.println(atomicInteger.get());

        System.out.println(atomicInteger.compareAndSet(2021, 2020));
        System.out.println(atomicInteger.get());

        // 期望的线程
        System.out.println(atomicInteger.compareAndSet(2020,666));
        System.out.println(atomicInteger.get());
    }
}

可以看到A不知情，并且正常进行了更新值，（这也是乐观锁的原理）

这是我们不期望的，如何解决这个问题？

20.原子引用

解决 ABA 问题，对应的思想：就是使用了乐观锁

解决办法：带版本号的原子操作！

public class CASDemo {
     
    // CAS: compareAndSet 比较并交换
    public static void main(String[] args){
     
        // AtomicInteger atomicInteger = new AtomicInteger(2020);

        // 给值的同时 添加一个版本号，这里我们定为1
        AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(1, 1);
        // 开启两个线程
        new Thread(()->{
     
            int stamp = atomicStampedReference.getStamp();// 获得版本号
            System.out.println("a1=>"+stamp);
            // 为保证两者的版本号是同一个，我们暂停一下
            try {
     
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
     
                e.printStackTrace();
            }
            // 开始CAS 操作
            // 参数1:期望值，参数2:更新值，参数3:版本号，参数4:版本号下一步的操作
            System.out.println(atomicStampedReference.compareAndSet(1, 2, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
            System.out.println("a2=>"+stamp);
            // 再将期望值改回去，但是版本号还在累加
            System.out.println(atomicStampedReference.compareAndSet(2, 1, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
            System.out.println("a2=>"+stamp);
        }, "a").start();
        // b线程也对atomicStampedReference操作
        // 和乐观锁原理相同
        new Thread(()->{
     
            int stamp = atomicStampedReference.getStamp();// 获得版本号
            System.out.println("b1=>"+stamp);
            // 为保证两者的版本号是同一个，暂停时间更长一些
            try {
     
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
     
                e.printStackTrace();
            }
            System.out.println(atomicStampedReference.compareAndSet(1, 6, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
            System.out.println("b2=>"+stamp);
        }, "b").start();
    }
}

这样，在操作过程中，即使期望值发生了变化，我们也可以通过版本号得知发生了变化

这里有个小坑：

AtomicStampedReference
Integer 使用了对象缓存机制，默认范围是 -128~127，推荐使用静态工厂方法 valueOf 获取对象实例，而不是 new ，因为 valueOf 使用了缓存，而 new 一定会创建新的对象分配新的内存空间。
所以我们的期望值包装类，需要使用范围在 -128~127 才确保是同一个内存空间
当然实际使用时可能是个对象，不会有这个问题
即使是数字的话，我们也可重写equals来解决这个问题

21.各种锁的理解

公平锁、非公平锁

公平锁: 非常公平,先来后到,不允许插队

非公平锁: 非常不公平, 允许插队，默认都是非公平

 	public ReentrantLock() {
     
        sync = new NonfairSync(); //无参默认非公平锁
    }
    // 重载方法可以传参
 	public ReentrantLock(boolean fair) {
     
        sync = fair ? new FairSync() : new NonfairSync();//传参为true为公平锁
    }

可重入锁（递归锁）

释义:

可重入锁指的是可重复可递归调用的锁，在外层使用锁之后，在内层仍然可以使用，并且不发生死锁（前提得是同一个对象或者class），这样的锁就叫做可重入锁，而且是自动获得的

synchronized版本的可重入锁

public class Demo01 {
     
    public static void main(String[] args) {
     
        TestPhone phone = new TestPhone();
        new Thread(()->{
     
            //在调用sendMessage的方法时已经为phone加上了一把锁
            //而call方法又为其加上了一把锁
            phone.sendMessage();
        }, "A").start();
        new Thread(()->{
     
            phone.sendMessage();
        }, "B").start();
    }
}
class TestPhone {
     
    public synchronized void sendMessage() {
     
        System.out.println(Thread.currentThread().getName() + "sendMessage");
        call();// 这里也有所
    }
    public synchronized void call() {
     
        System.out.println(Thread.currentThread().getName() + "call");
    }
}

按照正常逻辑，A执行完发短信，应该释放锁，B也有机会在A打电话之前就能发短信，

然而运行测试发现，每次都是A发短信、打电话之后，B才有机会开始发短信

这说明，A进入到内层锁的时候仍然保留着外层的锁

Lock 版本的锁

public class Demo02 {
     
    public static void main(String[] args) {
     
        Phone2 phone2  = new Phone2();
        new Thread(()->{
     
            phone2.sms();
        }).start();
        new Thread(()->{
     
            phone2.sms();
        }).start();
    }
}
class Phone2{
     
    Lock lock = new ReentrantLock();
    public void sms(){
     
        lock.lock();//细节：这个两把锁，两个钥匙
        // lock 锁必须配对，否则就是死锁在里面，配对指的就是每加一把锁就要对应一个解锁
        try {
     
            System.out.println(Thread.currentThread().getName()+"=>sms");
            call();
        } catch (Exception e) {
     
            e.printStackTrace();
        } finally {
     
            lock.unlock();
        }
    }
    public void call(){
     
        try {
     
            lock.lock();
            System.out.println(Thread.currentThread().getName()+"=>call");
        } catch (Exception e) {
     
            e.printStackTrace();
        } finally {
     
            lock.unlock();
        }
    }
}

运行测试，也会得到同样的效果，需要注意的是lock/unlock必须成对出现，否则程序会死在里面

自旋锁

在上面的案例中，已经看到自旋锁

不断地的循环去尝试，直到成功为止

手写代码实现一个自旋锁

public class SpinlockDemo {
     
    // 默认
    // int为 0
    // thread 为 null
    AtomicReference<Thread> atomicReference=new AtomicReference<>();
    // 加锁
    public void myLock(){
     
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName()+"===> mylock");
        //自旋锁
        while (!atomicReference.compareAndSet(null,thread)){
     
            System.out.println(Thread.currentThread().getName()+" ==> 自旋中~");
        }
    }
    // 解锁
    public void myUnlock(){
     
        Thread thread=Thread.currentThread();
        System.out.println(thread.getName()+"===> myUnlock");
        atomicReference.compareAndSet(thread,null);
    }
}

开始使用这个自旋锁，t2直到发现满足条件才可以执行，一直在自旋

public class TestSpinLock {
     
    public static void main(String[] args) throws InterruptedException {
     
        // 这是Java提供的锁，我们暂时不用
        ReentrantLock reentrantLock = new ReentrantLock();
        reentrantLock.lock();
        reentrantLock.unlock();
        // 使用CAS实现我们写的自旋锁
        SpinlockDemo spinlockDemo = new SpinlockDemo();
        new Thread(()->{
     
            spinlockDemo.myLock();
            try {
     
                TimeUnit.SECONDS.sleep(2);
            } catch (Exception e) {
     
                e.printStackTrace();
            } finally {
     
                spinlockDemo.myUnlock();
            }
        },"t1").start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
     
            spinlockDemo.myLock();
            try {
     
                TimeUnit.SECONDS.sleep(2);
            } catch (Exception e) {
     
                e.printStackTrace();
            } finally {
     
                spinlockDemo.myUnlock();
            }
        },"t2").start();
    }
}

死锁

比如说，两个线程互相抢夺资源，谁都不释放锁就会形成死锁

怎么排除死锁，让死锁的四个条件中至少有一个不成立

public class DeadLock {
     
    public static void main(String[] args) {
     
        String lockA= "lockA";
        String lockB= "lockB";
        new Thread(new MyThread(lockA,lockB),"t1").start();
        new Thread(new MyThread(lockB,lockA),"t2").start();
    }
}
class MyThread implements Runnable{
     
    private String lockA;
    private String lockB;
    public MyThread(String lockA, String lockB) {
     
        this.lockA = lockA;
        this.lockB = lockB;
    }
    @Override
    public void run() {
     
        synchronized (lockA){
     
            System.out.println(Thread.currentThread().getName()+" lock"+lockA+"===>get"+lockB);
            try {
     
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
     
                e.printStackTrace();
            }
            synchronized (lockB){
     
                System.out.println(Thread.currentThread().getName()+" lock"+lockB+"===>get"+lockA);
            }
        }
    }
}

程序卡死，两个线程都拿着对方想要的锁不释放

当程序卡着不输出，如何排查是死锁问题？

使用Java自带工具

使用 jps 定位进程号

在命令行输入 jps -l 查看目前运行的Java进程

2. 使用 jstack 进程号查看进程信息，找到死锁问题

查看详细的堆栈信息，通常可以在最后找到

面试中，工作如何排查

大部分人会说查看日志，但是你可以说查看堆栈信息！

你可能感兴趣的:(Java进阶,juc,java,多线程,锁)

.gitlab-ci.yml 配置文件详解程序媛夏天 Git gitlab ci/cd .gitlab-ci.yml
个人主页：不爱吃糖的程序媛‍♂️作者简介：前端领域新星创作者、CSDN内容合伙人，专注于前端各领域技术，成长的路上共同学习共同进步，一起加油呀！✨系列专栏：前端面试宝典、JavaScript进阶、vue实战资料领取：前端进阶资料以及文中源码可以在公众号“不爱吃糖的程序媛”领取git工具文档说明：https://docs.gitlab.com/ee/ci/yaml/gitlab_ci_yaml.ht
java中借助pdf导出 string world java pdf 开发语言
1.自定义注解部分代码：packagecom.fitk.emis.corp.export_Util.itextpdf.pdf;importjava.lang.annotation.ElementType;importjava.lang.annotation.Retention;importjava.lang.annotation.RetentionPolicy;importjava.lang.an
学习111 麋鹿叔叔学习
项目名称项目简介主要功能技术原理GitHub地址browser-use智能浏览器工具，让AI像人类一样操作浏览器，实现网页自动化网页浏览与操作、多标签页管理、视觉识别与内容提取、操作记录与重复执行、自定义动作支持、主流LLM模型支持为大语言模型服务的创新Python工具库GitHubEkoFellouAI推出的生产就绪型JavaScript框架，基于自然语言驱动创建智能代理支持所有平台，提供统一便
3.19学习总结 2402_88131930 学习
学习了Java中的面向对象的知识点完成一道算法题，找树左下角的值，错误的以为左下角只能是最底层的左节点，但指的是最底层最左边的节点
【从零开始学习JAVA】异常体系介绍 Cools0613 从0开始学Java 学习
前言：本文我们将为大家介绍一下异常的整个体系，而我们学习异常，不是为了敲代码的时候不出异常，而是为了能够熟练的处理异常，如何解决代码中的异常。异常的两大分类：我们就以这张图作为线索来详细介绍一下Java中的异常：1.Exceptions（异常）在Java中，Exception（异常）是一种表示非致命错误或异常情况的类或接口。Exception通常是由应用程序引发的，可以被程序员捕获、处理或抛出。E
输了，腾讯golang一面凉了 golang学习记 golang golang
本月正值4月，是金三银四的找工作的最佳时机。同时竞争也是很大，因为每年这个时候快要毕业的大学生也进去了找工作的潮水中。今天分享我的一位大佬朋友CC，勇闯腾讯golang的面试经历。这次面试问题的方向主要集中在计算机基础个网络方面。下面是主要问到的问题。第一个，http握手，https证书第二个，操作系统的中断，堆和栈第三个，数据库，乐观锁，悲观锁，acid等TSL四次握手的过程是什么第一次握手首先
android sqlite 数据库简单封装示例（java） mmsx android 作业源码分享 java 数据库 android
sqlite数据库简单封装示例，使用记事本数据库表进行示例。首先继承SQLiteOpenHelper使用sql语句进行创建一张表。publicclassnoteDBHelperextendsSQLiteOpenHelper{publicnoteDBHelper(Contextcontext,Stringname,SQLiteDatabase.CursorFactoryfactory,intvers
java工程师常用开发工具 Monika Zhang 开发工具 java
背景：最近换新电脑，记录下本岗位需要安装的软件，也顺便给大家参考，欢迎各位留言补充1JDK（JavaDevelopmentKit）JDK是Java程序员开发Java应用程序所必需的软件包。下载地址：JavaDownloads|Oracle安装配置教程：window下win10jdk8安装与环境变量的配置（超级详细）_jdk8环境变量配置-CSDN博客目前主流的JDK版本还是JAVA8查看版本命令：
PHP与Java的区别分析 Monika Zhang java 架构设计 php java 开发语言
一、语言特点php：一种的像Python的动态弱语言类型的服务器脚本语言，不需要编译代码；它是专为Web开发目的而开发和设计的，而且简单容易上手。Java：是一种通用的面向对象编程语言，属于强势优选语言类型，在执行前必须先正确编译。是面向对象的和人类可读的；支持服务器端和客户端；可用于开发独立应用程序或基于Web的应用程序，上手比PHP难。二、语法1.PHP是一种脚本语言，代码在服务器上执行，而结
Android 12.0 WiFi连接流程分析之IP地址分配流程安卓兼职framework应用工程师 android 12.0 Rom开发疑难问题分析 android tcp/ip wifi连接 ip地址分配ip
1.前言在12.0的系统rom定制化开发中，对于wifi的定制功能也是比较多的，在关于wifi连接流程模块的分析，了解整个wifi连接流程也是非常重要的，接下来看下wifi的连接流程分析下相关功能实现2.WiFi连接流程分析之IP地址分配流程的核心类frameworks/opt/net/wifi/service/java/com/android/server/wifi/ClientModeImpl
Maven简介 z迦在线 maven java
Maven简介Maven是Apache软件基金会的一个开源项目,是一个优秀的项目构建工具,它用来帮助开发者管理项目中的jar,以及jar之间的依赖关系、完成项目的编译（.java--->.class）、测试、打包（源代码--->.jar文件）和发布等工作。Maven是如何管理项目中的jar文件的？Maven简化了Java项目中的JAR文件管理，主要通过以下几个关键点：POM文件：Maven使用po
Java基础 3.22 anlogic java java 开发语言 jvm
1.break练习//1-100之内的数求和，求当和第一次大于20的当前数ipublicclassBreak01{publicstaticvoidmain(String[]args){intn=0;intcount=0;for(inti=1;i20){n=i;System.out.println("和大于20，退出循环，当前i为"+n);break;}}}}//实现登录验证，有3次机会，如果用户名
《java面向对象(5)》＜不含基本语法＞ java小白板 java 开发语言
本笔记基于黑马程序员java教程整理，仅供参考1.异常1.1异常分类1.1.1Error指系统级别的错误，程序员无法解决，不必理会1.1.2Exception（异常）分为两类：RuntimeException：运行时异常，编译时程序不会报错，运行时报错，如数组越界其他异常：编译时异常，编译时就会报错运行时异常：publicclassText{publicstaticvoidmain(String[
Oracle数据库与Java全栈开发一篇搞定（指南式教学） Aphelios380 Oracle 数据库 oracle java
一、基础操作篇1.数据定义语言（DDL）核心操作1.1表结构设计技巧--电商用户表设计示例CREATETABLEtb_users(user_idNUMBER(10)PRIMARYKEY,usernameVARCHAR2(30)UNIQUENOTNULL,passwordCHAR(32)DEFAULT'e10adc3949ba59abbe56e057f20f883e',emailVARCHAR2(5
Javascript基础 GesLuck javascript 开发语言 ecmascript
目录1.变量声明2.基本数据类型3.复杂数据类型4.字符串方法5.对象方法6.时间方法7.条件（if）8.循环（for/while）9.遍历（forin/of）10.多选（Switch）END1.变量声明const：除非变量需要重新赋值（优先使用）——consta=true;let：需要修改值时使用{大括号内用}（其次使用）——letb="hello"var：除非维护旧代码（避免使用）——varc
Java学习------常用类String 日暮南城故里 Java学习记录 java 学习开发语言 String类
1.介绍Java中的String属于引用数据类型，Java专门在堆中准备了一个字符串常量池。我们在开发时，字符串使用的频率是很高的，因此将这些字符串放在常量池中可以省去对象的创建过程，提高效率。常量池属于一种缓存技术，缓存技术是一种可以提高程序执行效率的手段。Strings1=“hello”;Strings2=“hello”;System.out.println(s1==s2);//这里输出的结果
Eclipse 快捷键 lsx202406 开发语言
Eclipse快捷键Eclipse是一款功能强大的集成开发环境（IDE），广泛应用于Java开发领域。熟练掌握Eclipse的快捷键可以大大提高开发效率。本文将详细介绍Eclipse中一些常用的快捷键，帮助开发者更快地熟悉和使用Eclipse。1.基础操作1.1打开文件Ctrl+O：快速打开文件Ctrl+Shift+O：查找类或文件1.2保存文件Ctrl+S：保存当前文件1.3运行程序Ctrl+F
JavaScript 箭头函数使用总结及注意事项（适合新手到进阶）我真聪明。 javascript 开发语言 ecmascript
箭头函数（=>）是ES6的核心特性之一，它简化了函数写法并改变了this的指向逻辑，但在使用时需要明确其适用场景和限制。以下是详细总结：一、箭头函数核心特点简洁语法：//传统函数constadd=function(a,b){returna+b;};//箭头函数constadd=(a,b)=>a+b;//单行省略returnconstadd=(a,b)=>{returna+b;};//多行需显式re
Spring Boot 3.2+ 升级Mybatis-Plus 3.5.x 兼容性问题与解决方案Invalid value type for attribute ‘factoryBeanObjectT z2637305611 spring boot mybatis 后端
一、当升级遭遇滑铁卢当我们将SpringBoot升级到3.2.0+版本时，熟悉的Invalidvaluetypeforattribute'factoryBeanObjectType':java.lang.String错误突然吞噬了控制台。这个看似神秘的错误频繁出现在整合Mybatis-Plus3.5.x时，甚至会附赠Invalidbeandefinitionwithname'xxxMapper'的
JAVA泛型的作用时光呢 java windows python
‌1.类型安全（TypeSafety）‌在泛型出现之前，集合类（如ArrayList、HashMap）只能存储Object类型元素，导致以下问题：‌问题‌：从集合中取出元素时，需手动强制类型转换，容易因类型不匹配导致运行时错误（如ClassCastException）。//JDK1.4时代：非泛型示例Listlist=newArrayList();list.add("Hello");Integer
使用 React 和 Cypress 进行单元测试 pxr007 单元测试 react.js junit
每个开发人员都希望发布一个没有错误的生产应用程序。为了实现这一点，我们需要考虑如何将测试集成到我们的应用程序中。我们可以使用许多测试工具、框架和测试类型。Cypress是一个现代化的自动化测试套件。它是一个基于JavaScript的完全开源的测试框架，由Mocha和Chai等支持BDD和TDD断言样式的库构建。此外，如果您熟悉用JavaScript编写测试，那么使用Cypress会很容易。Cypr
无锁并发环形队列(Java版) 呆呆的蜗牛数据结构和算法队列 java 多线程
环形队列是顺序队列的一种。普通的顺序队列，当队列不满且tail指针移动到数组的最后位置时，就需要将数组中的元素整体向前搬移，而环形队列却不用。这就提高了入队的效率。无锁并发主要基于CAS原理，在java中Unsafe类中提供了底层的CAS操作。但是我们可以不直接操作Unsafe类，JDK提供了一系列的Atomic类来满足一般的无锁需求。importjava.util.concurrent.atom
Stream 流中 flatMap 方法详解遇见伯灵说 Java 开发语言 java stream流
1.flatMap()到底是啥？flatMap()是Stream里的中间操作，它的作用可以分两步理解：第一步：对流里的每个元素，先**映射（转换）**成一个Stream。第二步：把多个子流拍平成一个大的扁平流。简单记忆：map()是一对一，flatMap()是一对多。️2.基础用法拆解来看个例子：Listlist=List.of("HelloWorld","JavaStream");Listres
双一流软件工程大二听闻 Java 前景堪忧，是否该转C++或人工智能或者读研？程序员yt java c++人工智能
今天给大家分享的是一位粉丝的提问，双一流软件工程大二听闻Java前景堪忧，是否该转C++或人工智能或者读研？接下来把粉丝的具体提问和我的回复分享给大家，希望也能给一些类似情况的小伙伴一些启发和帮助。同学提问：yt老师好，我是双一流软件工程的大二学生，一直在学习java方向，目前掌握了数据库，spring框架等内容，大一暑假在老家一个小公司找了段实习，有蓝桥杯java组b组国一，专业排名前2（保研名
深入解析 Java Stream API：筛选根节点的优雅实现！！！小丁学Java #Lambda表达式 #Stream java Stream Lambda 表达式 Collectors
深入解析JavaStreamAPI：筛选根节点的优雅实现大家好！今天我们来聊聊Java8中一个非常常见的操作：使用StreamAPI从List中筛选出特定条件的元素。具体来说，我们将深入分析以下代码片段：Listroots=inviteCodes.stream().filter(ic->ic.getCreatedBy()==null).collect(Collectors.toList());这段
【架构设计】前置知识 GIS程序媛—椰子架构设计架构设计
架构设计是软件开发的进阶技能，需要结合理论知识和实践经验。以下是掌握架构设计所需的前置知识及其重要性，以及学习路径建议：一、基础编程能力1.编程语言与核心概念掌握至少一门主流语言（如Java、Python、C#、Go等），理解其语法、特性及生态。核心概念：面向对象（OOP）、函数式编程（FP）、并发/异步、内存管理等。示例：通过Java理解接口、多态、设计模式。通过Go学习并发模型（Gorouti
带你了解Java无锁并发CAS 高锰酸钾_ java 并发
带你了解Java无锁并发CAS在多核处理器时代，并发编程已成为提升系统性能的核心手段。传统的同步机制（如synchronized和ReentrantLock）通过互斥锁实现线程安全，但其存在以下关键问题：性能损耗：线程阻塞/唤醒涉及内核态切换，单次操作耗时约1微秒（百万条指令时间）优先级反转：高优先级线程可能被低优先级线程阻塞死锁风险：不正确的锁顺序可能导致系统冻结今天带你了解另一种保证线程安全的
dubbo服务META-INF.dubbo文件夹作用 zhglhy dubbo java apache
META-INF.dubbo文件夹是ApacheDubbo框架中的一个重要目录，通常用于存放Dubbo的SPI（ServiceProviderInterface）扩展配置文件。Dubbo是一个高性能的JavaRPC框架，支持分布式服务治理，而SPI机制是Dubbo实现可扩展性的核心设计之一。1.SPI机制简介SPI是Java提供的一种服务发现机制，允许框架在运行时动态加载实现类。Dubbo对其进行
TreeNode底层实现原理 zhglhy 开发语言 java
TreeNode是树结构的基本单元，通常用于表示树形数据结构中的节点。其底层实现原理涉及以下几个方面：1.TreeNode的基本结构在Java中，TreeNode通常是一个类，包含以下核心属性：数据域：存储节点的数据。子节点引用：指向子节点的引用（对于二叉树，通常是左子节点和右子节点）。父节点引用：指向父节点的引用（可选，取决于具体实现）。以下是一个典型的二叉树节点的实现：classTreeNod
Java设计模式——装饰模式爱吃土豆的程序员 Java设计模式 java 装饰器模式设计模式
目录模式动机模式定义模式结构类图代码分析示例：动态添加功能的流组件接口具体组件装饰抽象类具体装饰类客户端模式分析核心思想动态扩展功能组合优于继承优点动态扩展功能组合优于继承代码复用性高符合开闭原则缺点增加系统的复杂性类的膨胀复杂的调试适用环境动态扩展功能避免继承带来的类爆炸性增长高度可定制化的需求模式应用输入输出流GUI组件日志记录模式扩展多层次装饰结合其他设计模式总结模式动机一般有两种方式可以实
web报表工具FineReport常见的数据集报错错误代码和解释老A不折腾 web报表 finereport 代码可视化工具
在使用finereport制作报表，若预览发生错误，很多朋友便手忙脚乱不知所措了，其实没什么，只要看懂报错代码和含义，可以很快的排除错误，这里我就分享一下finereport的数据集报错错误代码和解释，如果有说的不准确的地方，也请各位小伙伴纠正一下。 NS-war-remote=错误代码\:1117 压缩部署不支持远程设计 NS_LayerReport_MultiDs=错误代码
Java的WeakReference与WeakHashMap bylijinnan java 弱引用
首先看看 WeakReference wiki 上 Weak reference 的一个例子： public class ReferenceTest { public static void main(String[] args) throws InterruptedException { WeakReference r = new Wea
Linux——（hostname）主机名与ip的映射 eksliang linux hostname
一、什么是主机名无论在局域网还是INTERNET上，每台主机都有一个IP地址，是为了区分此台主机和彼台主机，也就是说IP地址就是主机的门牌号。但IP地址不方便记忆，所以又有了域名。域名只是在公网（INtERNET)中存在，每个域名都对应一个IP地址，但一个IP地址可有对应多个域名。域名类型 linuxsir.org 这样的；主机名是用于什么的呢？答：在一个局域网中，每台机器都有一个主
oracle 常用技巧 18289753290
oracle常用技巧 ①复制表结构和数据 create table temp_clientloginUser as select distinct userid from tbusrtloginlog ②仅复制数据如果表结构一样 insert into mytable select * &nb
使用c3p0数据库连接池时出现com.mchange.v2.resourcepool.TimeoutException 酷的飞上天空 exception
有一个线上环境使用的是c3p0数据库，为外部提供接口服务。最近访问压力增大后台tomcat的日志里面频繁出现 com.mchange.v2.resourcepool.TimeoutException: A client timed out while waiting to acquire a resource from com.mchange.v2.resourcepool.BasicResou
IT系统分析师如何学习大数据蓝儿唯美大数据
我是一名从事大数据项目的IT系统分析师。在深入这个项目前需要了解些什么呢？学习大数据的最佳方法就是先从了解信息系统是如何工作着手，尤其是数据库和基础设施。同样在开始前还需要了解大数据工具，如Cloudera、Hadoop、Spark、Hive、Pig、Flume、Sqoop与Mesos。系统分析师需要明白如何组织、管理和保护数据。在市面上有几十款数据管理产品可以用于管理数据。你的大数据数据库可能
spring学习——简介 a-john spring
Spring是一个开源框架，是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只能由EJB完成的事情。然而Spring的用途不仅限于服务器端的开发，从简单性，可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。其主要特征是依赖注入、AOP、持久化、事务、SpringMVC以及Acegi Security 为了降低Java开发的复杂性，
自定义颜色的xml文件 aijuans xml
<?xml version="1.0" encoding="utf-8"?> <resources> <color name="white">#FFFFFF</color> <color name="black">#000000</color> &
运营到底是做什么的？ aoyouzi 运营到底是做什么的？
文章来源：夏叔叔（微信号：woshixiashushu），欢迎大家关注！很久没有动笔写点东西，近些日子，由于爱狗团产品上线，不断面试，经常会被问道一个问题。问：爱狗团的运营主要做什么？答：带着用户一起嗨。为什么是带着用户玩起来呢？究竟什么是运营？运营到底是做什么的？那么，我们先来回答一个更简单的问题——互联网公司对运营考核什么？以爱狗团为例，绝大部分的移动互联网公司，对运营部门的考核分为三块——用
js面向对象类和对象百合不是茶 js 面向对象函数创建类和对象
接触js已经有几个月了,但是对js的面向对象的一些概念根本就是模糊的,js是一种面向对象的语言但又不像java一样有class,js不是严格的面向对象语言 ,js在java web开发的地位和java不相上下 ,其中web的数据的反馈现在主流的使用json,json的语法和js的类和属性的创建相似下面介绍一些js的类和对象的创建的技术一:类和对
web.xml之资源管理对象配置 resource-env-ref bijian1013 java web.xml servlet
resource-env-ref元素来指定对管理对象的servlet引用的声明，该对象与servlet环境中的资源相关联 <resource-env-ref> <resource-env-ref-name>资源名</resource-env-ref-name> <resource-env-ref-type>查找资源时返回的资源类
Create a composite component with a custom namespace sunjing
https://weblogs.java.net/blog/mriem/archive/2013/11/22/jsf-tip-45-create-composite-component-custom-namespace When you developed a composite component the namespace you would be seeing would
【MongoDB学习笔记十二】Mongo副本集服务器角色之Arbiter bit1129 mongodb
一、复本集为什么要加入Arbiter这个角色回答这个问题，要从复本集的存活条件和Aribter服务器的特性两方面来说。什么是Artiber？ An arbiter does not have a copy of data set and cannot become a primary. Replica sets may have arbiters to add a
Javascript开发笔记白糖_ JavaScript
获取iframe内的元素通常我们使用window.frames["frameId"].document.getElementById("divId").innerHTML这样的形式来获取iframe内的元素，这种写法在IE、safari、chrome下都是通过的，唯独在fireforx下不通过。其实jquery的contents方法提供了对if
Web浏览器Chrome打开一段时间后，运行alert无效 bozch Web chorme alert 无效
今天在开发的时候，突然间发现alert在chrome浏览器就没法弹出了，很是怪异。试了试其他浏览器，发现都是没有问题的。开始想以为是chorme浏览器有啥机制导致的，就开始尝试各种代码让alert出来。尝试结果是仍然没有显示出来。这样开发的结果，如果客户在使用的时候没有提示，那会带来致命的体验。哎，没啥办法了就关闭浏览器重启。结果就好了，这也太怪异了。难道是cho
编程之美-高效地安排会议图着色问题贪心算法 bylijinnan 编程之美
import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Random; public class GraphColoringProblem { /**编程之美高效地安排会议图着色问题贪心算法 * 假设要用很多个教室对一组
机器学习相关概念和开发工具 chenbowen00 算法 matlab 机器学习
基本概念：机器学习(Machine Learning, ML)是一门多领域交叉学科，涉及概率论、统计学、逼近论、凸分析、算法复杂度理论等多门学科。专门研究计算机怎样模拟或实现人类的学习行为，以获取新的知识或技能，重新组织已有的知识结构使之不断改善自身的性能。它是人工智能的核心，是使计算机具有智能的根本途径，其应用遍及人工智能的各个领域，它主要使用归纳、综合而不是演绎。开发工具 M
[宇宙经济学]关于在太空建立永久定居点的可能性 comsci 经济
大家都知道,地球上的房地产都比较昂贵,而且土地证经常会因为新的政府的意志而变幻文本格式........ 所以,在地球议会尚不具有在太空行使法律和权力的力量之前,我们外太阳系统的友好联盟可以考虑在地月系的某些引力平衡点上面,修建规模较大的定居点
oracle 11g database control 证书错误 daizj oracle 证书错误 oracle 11G 安装
oracle 11g database control 证书错误 win7 安装完oracle11后打开 Database control 后，会打开em管理页面，提示证书错误，点“继续浏览此网站”，还是会继续停留在证书错误页面解决办法：是 KB2661254 这个更新补丁引起的，它限制了 RSA 密钥位长度少于 1024 位的证书的使用。具体可以看微软官方公告：
Java I/O之用FilenameFilter实现根据文件扩展名删除文件游其是你 FilenameFilter
在Java中，你可以通过实现FilenameFilter类并重写accept(File dir, String name) 方法实现文件过滤功能。在这个例子中，我们向你展示在“c:\\folder”路径下列出所有“.txt”格式的文件并删除。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
C语言数组的简单以及一维数组的简单排序算法示例，二维数组简单示例 dcj3sjt126com c array
# include <stdio.h> int main(void) { int a[5] = {1, 2, 3, 4, 5}; //a 是数组的名字 5是表示数组元素的个数，并且这五个元素分别用a[0], a[1]...a[4] int i; for (i=0; i<5; ++i) printf("%d\n",
PRIMARY, INDEX, UNIQUE 这3种是一类 PRIMARY 主键。就是唯一且不能为空。 INDEX 索引，普通的 UNIQUE 唯一索引 dcj3sjt126com primary
PRIMARY, INDEX, UNIQUE 这3种是一类PRIMARY 主键。就是唯一且不能为空。INDEX 索引，普通的UNIQUE 唯一索引。不允许有重复。FULLTEXT 是全文索引，用于在一篇文章中，检索文本信息的。举个例子来说，比如你在为某商场做一个会员卡的系统。这个系统有一个会员表有下列字段：会员编号 INT会员姓名
java集合辅助类 Collections、Arrays shuizhaosi888 Collections Arrays HashCode
Arrays、Collections 1 ）数组集合之间转换 public static <T> List<T> asList(T... a) { return new ArrayList<>(a); } a）Arrays.asL
Spring Security（10）——退出登录logout 234390216 logout Spring Security 退出登录 logout-url LogoutFilter
要实现退出登录的功能我们需要在http元素下定义logout元素，这样Spring Security将自动为我们添加用于处理退出登录的过滤器LogoutFilter到FilterChain。当我们指定了http元素的auto-config属性为true时logout定义是会自动配置的，此时我们默认退出登录的URL为“/j_spring_secu
透过源码学前端之 Backbone 三 Model 逐行分析JS源代码 backbone 源码分析 js学习
Backbone 分析第三部分 Model 概述： Model 提供了数据存储，将数据以JSON的形式保存在 Model的 attributes里，但重点功能在于其提供了一套功能强大，使用简单的存、取、删、改数据方法，并在不同的操作里加了相应的监听事件，如每次修改添加里都会触发 change，这在据模型变动来修改视图时很常用，并且与collection建立了关联。
SpringMVC源码总结（七）mvc:annotation-driven中的HttpMessageConverter 乒乓狂魔 springMVC
这一篇文章主要介绍下HttpMessageConverter整个注册过程包含自定义的HttpMessageConverter，然后对一些HttpMessageConverter进行具体介绍。 HttpMessageConverter接口介绍： public interface HttpMessageConverter<T> { /** * Indicate
分布式基础知识和算法理论 bluky999 算法 zookeeper 分布式一致性哈希 paxos
分布式基础知识和算法理论 BY [email protected] 本文永久链接：http://nodex.iteye.com/blog/2103218 在大数据的背景下，不管是做存储，做搜索，做数据分析，或者做产品或服务本身，面向互联网和移动互联网用户，已经不可避免地要面对分布式环境。笔者在此收录一些分布式相关的基础知识和算法理论介绍，在完善自我知识体系的同
Android Studio的.gitignore以及gitignore无效的解决 bell0901 android gitignore
　　github上.gitignore模板合集，里面有各种.gitignore ： https://github.com/github/gitignore 　　自己用的Android Studio下项目的.gitignore文件，对github上的android.gitignore添加了　　　　　　# OSX files　　　　　　//mac os下　　　　　　.DS_Store
成为高级程序员的10个步骤 tomcat_oracle 编程
What 软件工程师的职业生涯要历经以下几个阶段：初级、中级，最后才是高级。这篇文章主要是讲如何通过 10 个步骤助你成为一名高级软件工程师。 Why 得到更多的报酬！因为你的薪水会随着你水平的提高而增加提升你的职业生涯。成为了高级软件工程师之后，就可以朝着架构师、团队负责人、CTO 等职位前进历经更大的挑战。随着你的成长，各种影响力也会提高。
mongdb在linux下的安装 xtuhcy mongodb linux
一、查询linux版本号： lsb_release -a LSB Version: :base-4.0-amd64:base-4.0-noarch:core-4.0-amd64:core-4.0-noarch:graphics-4.0-amd64:graphics-4.0-noarch:printing-4.0-amd64:printing-4.0-noa