学姐天天缠着问我JUC，搞得我没有时间打游戏，无奈之下我写下JUC基础，要她自己去研究下

Posted 2021-06-16 Code_BinBin

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了学姐天天缠着问我JUC，搞得我没有时间打游戏，无奈之下我写下JUC基础，要她自己去研究下相关的知识，希望对你有一定的参考价值。

上接文章：学姐天天缠着问我JUC，搞得我没有时间打游戏，无奈之下我写下JUC基础，要她自己去研究上

“学弟，JUC你还没有讲完呢，我还等着去和面试官对线呢”
“别急学姐，我们今天继续讲”我说道。

在这里插入图片描述

四大函数式接口

作为00后程序员，我们必须要学会lambda表达式、链式编程、函数式接口、Stream流式计算

函数式接口：只有一个方法的接口

@FunctionalInterface 
public interface Runnable { 
    public abstract void run(); 
}
// 泛型、枚举、反射 
// lambda表达式、链式编程、函数式接口、Stream流式计算 
// 超级多FunctionalInterface 
// 简化编程模型，在新版本的框架底层大量应用！ 
// foreach(消费者类的函数式接口)

Function 函数式接口

在这里插入图片描述

package com.znb.function;

import java.util.function.Function;

public class Test01 {
    public static void main(String[] args) {


       /*Function<String,String> function = new
        								Function<String,String>() {
            @Override
            public String apply(String str) {
                return str;
            }
        };*/

        // lambda 表达式简化：
        Function<String,String> function = str->{return str;};

        System.out.println(function.apply("asd"));
    }
}

Predicate 断定型接口

有一个输入参数，返回值只能是布尔值！

在这里插入图片描述

package com.znb.function;

import java.util.function.Predicate;

public class Test02 {
    public static void main(String[] args) {
        // 判断字符串是否为空
        /*Predicate<String> predicate = new Predicate<String>(){
            @Override
            public boolean test(String str) {
                return str.isEmpty();//true或false
            }
        };*/

        Predicate<String> predicate =
                (str)->{return str.isEmpty(); };

        System.out.println(predicate.test(""));//true
    }

}

Consumer 消费型接口

只有输入，没有返回值

在这里插入图片描述

package com.znb.function;

import java.util.function.Consumer;

public class Test03 {
    public static void main(String[] args) {
        /*Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String str) {
                System.out.println(str);
            }
        };*/
        Consumer<String> consumer =
                (str)->{System.out.println(str);};

        consumer.accept("sdadasd");
    }

}

Supplier 供给型接口

没有参数，只有返回值

package com.znb.function;

import java.util.function.Supplier;

public class Test04 {
    public static void main(String[] args) {
        /*Supplier supplier = new Supplier<Integer>() {
            @Override
            public Integer get() {
                System.out.println("get()");
                return 1024;
            }
        };*/

        Supplier supplier = ()->{ return 1024; };
        System.out.println(supplier.get());
    }

}

Stream 流式计算

什么是Stream流式计算

大数据：存储 + 计算
集合、mysql 本质就是存储东西的；
计算都应该交给流来操作！

这个可以看一下我之前写的博客
Lambda表达式

ForkJoin

什么是 ForkJoin

ForkJoin 在 JDK 1.7 ，并行执行任务！提高效率。大数据量！
大数据：Map Reduce （把大任务拆分为小任务）

ForkJoin 特点：工作窃取

打个比方，小红和小明同时去搬一百个箱子，一段时间后小红搬了50个，小明搬完了，然后小明就去帮小红搬，这样就最大限度的利用了线程

package com.znb.forkjoin;

import java.util.concurrent.RecursiveTask;

public class ForkJoinDemo extends RecursiveTask<Long> {

    private Long start;  // 1
    private Long end;    // 1990900000

    // 临界值
    private Long temp = 10000L;

    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 { // forkjoin 递归
            long middle = (start + end) / 2; // 中间值
            ForkJoinDemo task1 = new ForkJoinDemo(start, middle);
            task1.fork(); // 拆分任务，把任务压入线程队列
            ForkJoinDemo task2 = new ForkJoinDemo(middle+1, end);
            task2.fork(); // 拆分任务，把任务压入线程队列

            return task1.join() + task2.join();
        }
    }
}

测试代码

package com.znb.forkjoin;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.stream.LongStream;

/**
 * 同一个任务，别人效率高你几十倍！
 */
public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
//         test1(); // 12224
         test2(); // 10038
//         test3(); // 153
    }

    // 普通程序员
    public static void test1(){
        Long sum = 0L;
        long start = System.currentTimeMillis();
        for (Long i = 1L; i <= 10_0000_0000; i++) {
            sum += i;
        }
        long end = System.currentTimeMillis();
        System.out.println("sum="+sum+" 时间："+(end-start));
    }

    // 会使用ForkJoin
    public static void test2() throws ExecutionException, InterruptedException {
        long start = System.currentTimeMillis();

        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Long> task = new ForkJoinDemo(0L, 10_0000_0000L);
        // 提交任务
        ForkJoinTask<Long> submit = forkJoinPool.submit(task);

        Long sum = submit.get();// 获得结果

        long end = System.currentTimeMillis();

        System.out.println("sum="+sum+" 时间："+(end-start));
    }

    public static void test3(){
        long start = System.currentTimeMillis();
        // Stream并行流 ()  (]
        long sum = LongStream
                .rangeClosed(0L, 10_0000_0000L) // 计算范围(,]
                .parallel() // 并行计算
                .reduce(0, Long::sum); // 输出结果

        long end = System.currentTimeMillis();
        System.out.println("sum="+"时间："+(end-start));
    }
}

异步回调

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

package com.znb.future;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class Test01 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 没有返回值的 runAsync 异步回调
//        CompletableFuture<Void> completableFuture =
//        							CompletableFuture.runAsync(()->{
//            try {
//                TimeUnit.SECONDS.sleep(2);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//            System.out.println(
//        		Thread.currentThread().getName()+"runAsync=>Void");
//        });
//
//        System.out.println("1111");
//
//        completableFuture.get(); // 获取阻塞执行结果

        // 有返回值的 supplyAsync 异步回调
        // ajax，成功和失败的回调
        // 返回的是错误信息；
        CompletableFuture<Integer> completableFuture =
                CompletableFuture.supplyAsync(()->{
                    System.out.println(Thread.currentThread().getName()
                            +"supplyAsync=>Integer");
                    int i = 10/0;
                    return 1024;
                });

        System.out.println(completableFuture.whenComplete((t, u) -> {
            System.out.println("t=>" + t); // 正常的返回结果
            System.out.println("u=>" + u);
            // 错误信息：
            // java.util.concurrent.CompletionException:
            // java.lang.ArithmeticException: / by zero

        }).exceptionally((e) -> {
            System.out.println(e.getMessage());
            return 233; // 可以获取到错误的返回结果
        }).get());

        /**
         * succee Code 200
         * error Code 404 500
         */
    }

}

JMM

请你谈谈你对 Volatile 的理解

Volatile 是 Java 虚拟机提供轻量级的同步机制，类似于synchronized 但是没有其强大。

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

什么是JMM

JMM ： Java内存模型，不存在的东西，概念！约定！

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

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

8 种操作

在这里插入图片描述

内存交互操作有8种，虚拟机实现必须保证每一个操作都是原子的，不可在分的（对于double和long类型的变量来说，load、store、read和writ操作在某些平台上允许例外）

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

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操作之前，必须把此变量同步回主内存

问题：程序不知道主内存的值已经被修改过了

在这里插入图片描述

Volatile

保证可见性

我们设一个num，开启main线程和另外一个新的线程，新线程无限循环，直到num！=0

package com.znb.volatiles;

import java.util.concurrent.TimeUnit;

public class Test01 {
    private  static int num = 0;

    public static void main(String[] args) { // main

        new Thread(()->{ // 线程 1 对主内存的变化不知道的
            while (num==0){

            }
        }).start();

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

        num = 1;
        System.out.println(num);

    }

}

在这里插入图片描述

在这里并没有成功，因为我们没有使用volatile

package com.znb.volatiles;

import java.util.concurrent.TimeUnit;

public class Test01 {
    private volatile static int num = 0;

    public static void main(String[] args) { // main

        new Thread(()->{ // 线程 1 对主内存的变化不知道的
            while (num==0){

            }
        }).start();

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

        num = 1;
        System.out.println(num);

    }

}

成功

不保证原子性

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

volatile没有原子性，也就是说，当有好多好多个线程同时操作某一个数据的时候，就有可能会要很多线程的操作没有成功

package com.znb.volatiles;

import java.util.concurrent.atomic.AtomicInteger;

public class Test02 {
    // volatile 不保证原子性
    // 原子类的 Integer
    private volatile static int num = 0;

    public static void add(){
        // num++; // 不是一个原子性操作
        num++; // AtomicInteger + 1 方法， CAS
    }

    public static void main(String[] args) {

        //理论上num结果应该为 2 万
        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000 ; j++) {
                    add();
                }
            }).start();
        }

        // 判断只要剩下的线程不大于2个，就说明20个创建的线程已经执行结束
        while (Thread.activeCount()>2){ // Java 默认有 main gc 2个线程
            Thread.yield();
        }

        System.out.println(Thread.currentThread().getName()
                + " " + num);
    }

}

在这里插入图片描述
在这里我们运行了2万次，按理来说最后累计应该是20000，但是并没有，而且每一次的运行结果都是不一样的，那我我们要怎么办呢？在这里我们要使用AtomicInteger，这个类有原子性，不会有多个现场同时对一个数据进行修改的情况。

package com.znb.volatiles;

import java.util.concurrent.atomic.AtomicInteger;

public class Test02 {
    // volatile 不保证原子性
    // 原子类的 Integer
    private volatile static AtomicInteger num = new AtomicInteger();

    public static void add(){
        // num++; // 不是一个原子性操作
        num.getAndIncrement(); // AtomicInteger + 1 方法， CAS
    }

    public static void main(String[] args) {

        //理论上num结果应该为 2 万
        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                for (int j =以上是关于学姐天天缠着问我JUC，搞得我没有时间打游戏，无奈之下我写下JUC基础，要她自己去研究 下的主要内容，如果未能解决你的问题，请参考以下文章 
 这个数据太骚！搞得我都激动了。
 这个数据太骚！搞得我都激动了。
 pygame游戏用Python实现一个蔡徐坤大战篮球的小游戏，可还行？附源码
 OAuth,JWT ,OIDC你们搞得我好乱啊
 孩子贪玩游戏，不如玩少儿编程开发大脑
 360软件小助手一键加速的设置

学姐天天缠着问我JUC，搞得我没有时间打游戏，无奈之下我写下JUC基础，要她自己去研究 下

四大函数式接口

Function 函数式接口

Predicate 断定型接口

Consumer 消费型接口

Supplier 供给型接口

Stream 流式计算

什么是Stream流式计算

ForkJoin

什么是 ForkJoin

异步回调

JMM

请你谈谈你对 Volatile 的理解

什么是JMM

8 种操作

Volatile

保证可见性

不保证原子性

学姐天天缠着问我JUC，搞得我没有时间打游戏，无奈之下我写下JUC基础，要她自己去研究下