新时代的程序员:lambda表达式、链式编程、函数式接口、Stream流式计算
函数式接口:只有一个方法的接口
@FunctionalInterface
public interface Runnable {
public abstract void run();
}
//简化编程模型,在新版本的框架底层大量应用
//foreach(消费者类型的函数式接口)
代码测试:
函数式接口:funcation
import java.util.function.Function;
/**
* Function 函数类型接口,有一个输入参数,有一个输出
* 只要是 函数类型接口 可以 用 lambda 表达式简化
*/
public class FunctionTest {
public static void main(String[] args) {
/* Function<String,String> function = new Function<String,String>() {
@Override
public String apply(String str) {
return str;
}
};*/
Function<String,String> function = (str)->{return str;};
System.out.println(function.apply("aaa"));
}
}
断定型接口:Predicate
import java.util.function.Predicate;
/**
* 断定型接口: 有一个输入参数,返回值只能是 布尔值!
*/
public class PredicateTest {
public static void main(String[] args) {
Predicate<String> predicate = new Predicate<String>() {
//判断字符串是否为空
@Override
public boolean test(String str) {
return str.isEmpty();
}
};
// lambda表达式简化版
Predicate<String> predicate1 = str->{return str.isEmpty(); };
System.out.println(predicate.test(""));
System.out.println(predicate1.test("11"));
}
}
Consumer 消费型接口
import java.util.function.Consumer;
/**
* Consumer 消费型接口: 只有输入,没有返回值
*/
public class ConsumerTest {
public static void main(String[] args) {
Consumer<String> consumer = new Consumer<String>() {
@Override
public void accept(String str) {
System.out.println(str);
}
};
Consumer<String> consumer1 = str -> {
System.out.println(str);
};
consumer.accept("aaa");
consumer1.accept("bbb");
}
}
Supplier 供给型接口
import java.util.function.Supplier;
/**
* Supplier 供给型接口 没有参数,只有返回值
*/
public class SupplierTest {
public static void main(String[] args) {
Supplier<String> supplier = new Supplier<String>() {
@Override
public String get() {
System.out.println("get()");
return "1111";
}
};
Supplier<String> supplier1 = () -> {
return "2222";
};
System.out.println(supplier.get());
System.out.println(supplier1.get());
}
}
Stream 流式计算
import java.util.Arrays;
import java.util.List;
/**
* 题目要求:一分钟内完成此题,只能用一行代码实现!
* 现在有5个用户!筛选:
* 1、ID必须是偶数
* 2、年龄必须大于23岁
* 3、用户名转为大写字母
* 4、用户名字母倒着排序
* 5、只输出一个用户!
*/
public class Test {
public static void main(String[] args) {
Users u1 = new Users(1, "a", 21);
Users u2 = new Users(2, "b", 22);
Users u3 = new Users(3, "c", 23);
Users u4 = new Users(4, "d", 24);
Users u5 = new Users(6, "e", 25);
// 集合就是存储
List<Users> list = Arrays.asList(u1, u2, u3, u4, u5);
// 计算交给Stream流
list.stream().filter(u -> {
return u.getId() % 2 == 0;
}).filter(u -> {
return u.getAge() > 23;
}).map(u -> {
return u.getName().toUpperCase();
})
.sorted((id1, id2) -> {
return id2.compareTo(id1);
}).limit(1)
.forEach(System.out::println);
}
}
ForkJoin
ForkJoin在1.7,并行执行任务!提高效率,大数据量
大数据: Map Reduce(把大人物拆分为小任务)
ForkJoin 特点:工作窃取
这里面维护的都是双端队列
ForkJoinDemo:
import java.util.concurrent.RecursiveTask;
/**
* 求和计算的任务
* 30006000 (ForkJoin)900e (Stream并行流>//如何使用forkjoin
* 1、forkJoinPooL通过它来执行
* 计算任务forkJoinPooL.execute( ForkJoinTask task )
* 计算类 要继承 ForkJoinTask
*/
public class ForkJoinDemo extends RecursiveTask<Long> {
private Long start;
private Long end;
// 临界值
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();
}
}
}
test:
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(); 5670
// test2(); 4103
//test3(); 155
}
// 最普通的方法
private static void test1() {
long start = System.currentTimeMillis();
Long sum = 0L;
for (Long i = 1L; i <= 10_0000_0000; i++) {
sum += i;
}
long end = System.currentTimeMillis();
System.out.println("sum:=>" + sum + "时间:=>" + (end - start));
}
// 进阶版 ForkJoin
private 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));
}
// 进阶版 Stream 并行流
private 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:=>" + sum + "时间:=>" + (end - start));
}
异步回调
代码:
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
/**
* 异步回调: CompletableFuture
* 异步执行
* 成功回调
* 失败回调
*/
public class FutureTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
test2();
}
private static void test2() throws ExecutionException, InterruptedException {
// 发起一个请求 有返回值的 runAsync 异步回调
// Ajax,成功和失败的回调
// 返回的是错误信息
CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
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 404; // 可以获取到错误的返回结果
}).get());
}
private static void test1() throws InterruptedException, ExecutionException {
// 发起一个请求 没有返回值的 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("11111");
completableFuture.get(); // 获取阻塞执行结果
}
}
JMM
volatile 是JAVA 虚拟机提供轻量级的同步机制
1.保证可见性
2.不保证原子性
3.禁止指令重排
什么是JMM
JMM:JAVA内存模型,不存在的东西,概念,约定
关于JMM的一些同步的约定:
1.线程解锁前,必须把共享变量立刻刷回主存
2.线程加锁前,必须读取主存中的最新值到工作内存中
3.加锁和解锁是同一把锁
线程 工作内存,主内存
8种操作
内存交互操作有8种,虚拟机实现必须保证每一个操作都是原子的,不可在分的(对于double和long类型的变量来说,load、store、read和write操作在某些平台上允许例外)
-
- 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
1.保证可见性
import java.util.concurrent.TimeUnit;
public class JMMTest {
// 不加 volatile 程序就会死循环
// 加 volatile 保证可见性
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);
}
}
2.不保证原子性
原子性:不可分割
线程A在执行任务的时候,不能被打扰的,也不能被分割,要么同时成功,要么同时失败
// 不保证原子性
public class VolatileTest {
// volatile 不保证原子性
private volatile static int num = 0;
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();
}
while (Thread.activeCount()>2){
// java 默认有两个线程在执行 分别为 main线程 和gc线程
Thread.yield();
}
System.out.println(Thread.currentThread().getName() + " " + num);
}
public static void add() {
num++;
}
}
如果不加lock 和 synchronized ,怎么保证原子性
使用原子类,解决原子性问题
import java.util.concurrent.atomic.AtomicInteger;
// 不保证原子性
public class VolatileTest {
// volatile 不保证原子性
// 原子类的 Integer
private volatile static AtomicInteger num = new AtomicInteger();
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();
}
while (Thread.activeCount()>2){
// java 默认有两个线程在执行 分别为 main线程 和gc线程
Thread.yield();
}
System.out.println(Thread.currentThread().getName() + " " + num);
}
public static void add() {
num.getAndIncrement();// AtomicInteger + 1 方法,CAS
}
}
这些类的底层都直接和操作系统挂钩,在内存中改值,Unsafe类是一个很特殊的存在
指令重排
什么是指令重排:你写的程序,计算机并不是按照你写的那样去执行的
源代码-->编译器优化的重排-->指令并行也可能会重排-->内存系统也会重排-->执行
处理器在进行指令重排的时候,会考虑:数据之间的依赖性!
int x = 1; // 1
int y = 2; // 2
x = x + 5; // 3
y = x * x; // 4
// 我们所期望的是:1234按照顺序执行, 但是可能执行的时候会变成 2134 1324
可能造成的结果:
a、b、c、d这四个值默认都是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 |
指令重排导致的诡异结果:x = 2; y = 1;
Volatile可以避免指令重排:
内存屏障,CPU指令,作用:
1.保持特定的操作的执行顺序
2.可以保持某些变量的内存可见性(利用这些特性volatile实现了可见性)
Volatile 是可以保持 可见性,不能保证原子性,由于内存屏障,可以保证避免指令重排的现象产生
单例模式
饿汉式:
// 饿汉式单例
public class Hungry {
// 程序运行就会加载 可能会浪费空间
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 Hungry() {
}
private final static Hungry HUNGRY = new Hungry();
public static Hungry getInstance() {
return HUNGRY;
}
}
DCL懒汉式:
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
// 懒汉式单例模式
public class LazyMan {
private static boolean li = false;
private LazyMan() {
synchronized (LazyMan.class) {
if (li == false) {
li = true;
} else {
throw new RuntimeException("不要试图通过反射破坏程序");
}
/*if (lazyMan != null) {
//System.out.println("不要试图通过反射破坏程序");
}*/
}
}
private volatile static LazyMan lazyMan;
// 双重检测锁模式的 懒汉式单例 DCL 懒汉式
private static LazyMan getInstance() {
if (lazyMan == null) {
synchronized (LazyMan.class) {
if (lazyMan == null) {
lazyMan = new LazyMan(); // 这不是一个原子性的操作
/**他会先
* 1.分配内存空间
* 2.执行构造方法,初始化对象
* 3.把这个对象指向这个空间
* 我们期望的执行顺序为: 1、2、3
* 而可能执行的是 1、3、2 如果同时有两个线程 A执行 1、3
* B 此时 LazyMan还没有完成构造
*
*/
}
}
}
return lazyMan;
}
// 多线程并发
public static void main(String[] args) throws Exception {
/* for (int i = 0; i < 10; i++) {
new Thread(() -> {
LazyMan.getInstance();
}).start();
}*/
// 反射可以破坏这种懒汉单例模式
Field li = LazyMan.class.getDeclaredField("li");
li.setAccessible(true);
Constructor<LazyMan> declaredConstructor =
LazyMan.class.getDeclaredConstructor(null);
declaredConstructor.setAccessible(true); // 无视私有构造器
LazyMan lazyMan1 = declaredConstructor.newInstance();
li.set(lazyMan1, false);
LazyMan lazyMan2 = declaredConstructor.newInstance();
System.out.println(lazyMan1);
System.out.println(lazyMan2);
System.out.println(lazyMan1 == lazyMan2);
}
}
静态内部类:
// 静态内部类
public class Holder {
private Holder() {
}
public static Holder getInstance() {
return InnerClass.HOLDER;
}
public static class InnerClass {
private static final Holder HOLDER = new Holder();
}
}
单例不安全;反射
枚举
import java.lang.reflect.Constructor;
/**
* enum 是什么?
* 本身也是一个Class类
*/
public enum EnumSingle {
INSTANCE;
public EnumSingle getInstance() {
return INSTANCE;
}
}
class test {
public static void main(String[] args) throws NoSuchMethodException {
EnumSingle instance1 = EnumSingle.INSTANCE;
Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
declaredConstructor.setAccessible(true);
EnumSingle instance2 = EnumSingle.INSTANCE;
//NoSuchMethodException: com.li.single.EnumSingle.<init>()
System.out.println(instance1);
System.out.println(instance2);
}
}
CAS
什么是CAS
Unsafe类
import java.util.concurrent.atomic.AtomicInteger;
public class CASTest {
// CAS compareAndSet: 比较并交换
public static void main(String[] args) {
AtomicInteger atomicInteger = new AtomicInteger(2022);
// 期望、更新
// public final boolean compareAndSet(int expect, int update)
// 如果我们期望的值达到了,那么就更新,否则,就不更新 CAS 是CPU的并发原语
System.out.println(atomicInteger.compareAndSet(2022, 2023));
System.out.println(atomicInteger.get());
System.out.println(atomicInteger.compareAndSet(2022, 2023));
System.out.println(atomicInteger.get());
}
}
CAS:比较当前工作内存中的值和内存中的值,如果这个值是期望的,那么则执行操作,如果不是就一直循环
缺点:
1.循环会耗时
2.一次只能保证一个共享变量的原子性
3.ABA问题
CAS:ABA问题(狸猫换太子)
有两条线程A、B 在A执行之前 B把值发生了修改但A不知道这个值已经被改变
import java.util.concurrent.atomic.AtomicInteger;
public class CASTest {
// CAS compareAndSet: 比较并交换
public static void main(String[] args) {
AtomicInteger atomicInteger = new AtomicInteger(2022);
// 期望、更新
// public final boolean compareAndSet(int expect, int update)
// 如果我们期望的值达到了,那么就更新,否则,就不更新 CAS 是CPU的并发原语
// ======================= 捣乱的线程 ================
System.out.println(atomicInteger.compareAndSet(2022, 2023));
System.out.println(atomicInteger.get());
System.out.println(atomicInteger.compareAndSet(2023, 2022));
System.out.println(atomicInteger.get());
// ======================= 期望的线程 ================
System.out.println(atomicInteger.compareAndSet(2022, 1111));
System.out.println(atomicInteger.get());
}
}
原子引用:
带版本号的原子操作
Integer使用了对象缓存机制,默认范国是-128~127,推荐使用静态工厂方法valueof获取对象实例,而不是new ,因为valueOf使用缓存,而new一定会创建新的对象分配新的内存空间;
解决ABA问题,引入原子引用 对应思想:乐观锁
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicStampedReference;
public class CASDemo {
public static void main(String[] args) {
// AtomicStampedReference 注意,如果泛型是一个包装类,注意对象的引用问题
AtomicStampedReference<Integer> atomicInteger = new AtomicStampedReference<>(1, 1);
// 乐观锁原理相同
new Thread(() -> {
int stamp = atomicInteger.getStamp(); // 获得版本号
System.out.println("A1=>" + stamp);
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
atomicInteger.compareAndSet(1, 2,
atomicInteger.getStamp(), atomicInteger.getStamp() + 1);
System.out.println("A2=>" + atomicInteger.getStamp());
atomicInteger.compareAndSet(2, 1,
atomicInteger.getStamp(), atomicInteger.getStamp() + 1);
System.out.println("A2=>" + atomicInteger.getStamp());
}, "A").start();
new Thread(() -> {
int stamp = atomicInteger.getStamp(); // 获得版本号
System.out.println("B1=>" + stamp);
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
atomicInteger.compareAndSet(1, 3333,
stamp, stamp + 1);
System.out.println("B1=>" + atomicInteger.getStamp());
}, "B").start();
}
}
各种锁的理解·
公平锁、非公平锁
公平锁: 非常公平,不能够插队,必须先来后到
非公平锁:非常不公平,可以插队(默认都是非公平)
public ReentrantLock() {
sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
可重入锁
可重入锁(递归锁)
synchronized
// synchronized
public class Demo01 {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(() -> {
phone.sms();
}, "A").start();
new Thread(() -> {
phone.sms();
}, "B").start();
}
}
class Phone {
public synchronized void sms() {
System.out.println(Thread.currentThread().getName() + "=> sms");
call(); // 这里也有锁
}
public synchronized void call() {
System.out.println(Thread.currentThread().getName() + "=> call");
}
}
lock
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
// Lock
public class Demo02 {
public static void main(String[] args) {
Phone2 phone = new Phone2();
new Thread(() -> {
phone.sms();
}, "A").start();
new Thread(() -> {
phone.sms();
}, "B").start();
}
}
class Phone2 {
Lock lock = new ReentrantLock();
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() {
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + "=> call");
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
自旋锁
自定义锁测试
import java.util.concurrent.atomic.AtomicReference;
/**
* 自旋锁
*/
public class SpinlockTest {
AtomicReference<Thread> atomicReference = new AtomicReference<>();
// 加锁
public void myLock(){
Thread thread = Thread.currentThread();
System.out.println(Thread.currentThread().getName()+"==> myLock");
// 自旋锁
while (!atomicReference.compareAndSet(null,thread)){
}
}
// 解锁
public void myUnLock(){
Thread thread = Thread.currentThread();
System.out.println(Thread.currentThread().getName()+ "==>myUnLock");
atomicReference.compareAndSet(thread,null);
}
}
测试:
import java.util.concurrent.TimeUnit;
public class TestSpinlock {
public static void main(String[] args) throws InterruptedException {
// 底层使用的自旋锁CAS
SpinlockTest lock = new SpinlockTest();
new Thread(() -> {
lock.myLock();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.myUnLock();
}
}, "T1").start();
TimeUnit.SECONDS.sleep(1);
new Thread(() -> {
lock.myLock();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.myUnLock();
}
}, "T2").start();
}
}
死锁
死锁是什么
死锁测试,怎么排除死锁
import java.util.concurrent.TimeUnit;
public class DeadLockDemo {
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 + "=>" + lockB);
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lockB) {
System.out.println(Thread.currentThread().getName() + "lock:" + lockB + "=>" + lockA);
}
}
}
}
解决问题:
1.使用jps -l 定位进程号
2.使用jstack 进程号 找到死锁问题