JavaSE：JUC并发编程
目录
一些java特性
狂神说JUC课程学习，图片来源课程视频
1. 函数式接口
函数式接口：只有一个方法的接口，比如Runnable 接口Callable接口，@FunctionInterface。 函数式接口都可以用lambda表达式简化。
原生的函数式接口：
- Function：函数型接口 一个输入参数一个输出
import java.util.function.Function;
public class FunctionalInterface {
public static void main(String[] args) {
// Function function = new Function<String, String>() {
// @Override
// public String apply(String str) {
// return str;
// }
// };
Function function = (str)->{return str;};
System.out.println(function.apply("输入"));
}
}
- Predicate：断定型接口 返回值布尔型
import java.util.function.Predicate;
public class FunctionalInterface {
public static void main(String[] args) {
// Predicate<String> predicate = new Predicate<String>() {
// @Override
// public boolean test(String s) {
// return s.isEmpty();
// }
// };
Predicate<String> predicate = (str) -> {return str.isEmpty();};
System.out.println(predicate.test("输入"));
}
}
- Consumer：消费型接口 只有输入没有返回值
- Supplier：供给型接口 只有返回值没有输入
2.Stream流式计算
存储 计算交给流
// User类
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
private int id;
private String name;
private int age;
}
//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) {
User u1 = new User( 1, "a", 21);
User u2 = new User( 2, "b", 22);
User u3 = new User( 3, "c", 23);
User u4 = new User( 4, "d", 24);
User u5 = new User( 5, "r", 25);
// 使用集合存储
List<User> list = Arrays.asList(u1, u2, u3, u4, u5);
// 使用流计算
// 链式编程
list.stream()
.filter(u -> {return u.getId()%2 ==0;})
.filter(u -> {return u.getAge()>23;})
.map(u -> {return u.getName().toUpperCase();})
.sorted((uu1, uu2) ->{return uu2.compareTo(uu1);})
.limit(1)
.forEach(System.out::println);
}
}
JUC并发编程
狂神说JUC课程学习，图片来源课程视频
1. 基础知识
- java默认有两个线程：main、GC
- java实际上不能开启线程，而是通过本地的native方法调用C++，java不能直接操作硬件
- 并发不是并行，并发指多线程操作同一个资源，可以通过单核cpu快速交替；并行是多个线程同时执行。
- 线程有六种状态：NEW RUNNABLE BLOCKED WAITING（一直等待） TIMED_WAITING（超时等待） TERMINATED
- wait/sleep区别：
- 来自不同的类：wait Object sleep Thread
- wait会释放锁，sleep不
- wait必须在同步代码块中
- wait不需要捕获异常，sleep必须要捕获异常
2. Lock锁
2.1 基本概念
首先注意：回顾先前线程的创建方式，更安全的方法：线程就是一个单独的资源类，没有任何附属的操作。（使用lambda表达式调用普通类的方法）
- 公平锁：先来后到
- 非公平锁：可以插队（默认）
Synchronized和Lock区别：
- Synchronized内部关键字，Lock是内置的类
- Synchronized无法判断获取锁的状态
- Synchronized会自动释放锁
- Synchronized在获得锁的线程阻塞之后，另外的线程需要等待；Lock锁的tryLock方法不一定等待下去
- Synchronized是非公平锁，Lock可以自己设置。都是可重入锁
2.2 发电话发短信问题
synchronized锁的是对象，即该方法的调用者，谁先拿到谁执行，所以下列代码永远先发短信。
package com.zhang.lock;
import java.util.concurrent.TimeUnit;
public class Lock8 {
public static void main(String[] args) throws InterruptedException {
Phone phone = new Phone();
new Thread(()->{phone.sendSms();}, "A").start();
TimeUnit.SECONDS.sleep(1);
new Thread(()->{phone.call();}, "B").start();
}
}
class Phone{
public synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public synchronized void call() {
System.out.println("打电话");
}
}
使用一个普通方法hello，是先发短信还是hello？
- hello，普通方法不受锁的影响
两个对象，先发短信还是打电话？
- 打电话
在同步方法里加static，先发短信还是先打电话？
- 发短信，static方法在类一加载就有了，但此时锁的是class模版
在同步方法里加static，且用两个对象？
- 发短信，class模版只有一个
静态同步方法发短信，同步方法打电话？
- 打电话，因为锁的对象不一样
2.3 读写锁ReadWriteLock
ReadWriteLock readWriteLock = new ReetrantReadWriteLock();
更细粒度的控制，分别控制读和写。写的时候只允许一个线程写。而且先写后读。
独占锁（写锁）：一次只能被一个线程占有
共享锁（读锁）：多个线程可以同时占有
3.生产者消费者Lock版本
3.1 Synchronized版：wait notify方法
package com.zhang.pc;
public class A {
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 number = 0;
public synchronized void increment() throws InterruptedException {
if(number != 0) this.wait();
number++;
System.out.println(Thread.currentThread().getName() + "==>" +number);
this.notifyAll();
}
public synchronized void decrement() throws InterruptedException {
if(number == 0) this.wait();
number--;
System.out.println(Thread.currentThread().getName() + "==>" + number);
this.notifyAll();
}
}
问题：多个线程呢？
不会0101了！
虚假唤醒问题：wait方法放在while循环里，将上面代码的if换成while即可
3.2 JUC版PC问题
Condition await signal代替
问题：线程直接没有顺序？A-->B-->C-->A？
3.3 JUC版+
新建多个condition监视器
4.集合类不安全
4.1 List多线程不安全
ConcurrentModificationException 并发修改异常
// java.util.ConcurrentModificationException 并发修改异常
public class Unsafe {
public static void main(String[] args) {
/*
1. Vector<>是安全的
2. Collections.synchronizedList(new ArrayList<>())
3. new CopyOnWriteArrayList<>();
*/
List<String> list = new CopyOnWriteArrayList<>();
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();
}
}
}
CopyOnWrite（COW），写入时复制，在写入的时候避免覆盖
CopyOnWriteArrayList比Vector优点：sychronized方法较低
4.2 Set、Map不安全
和BlockingQueue、List都是实现Collection接口
方式1:Collections.synchronizedSet(new HashSet<>());
2.new CopyOnWriteArraySet<>();
ps：HashSet底层是什么？
Ans：就是Hashmap<>用键值
map默认参数？
Ans：初始化容量16，0.75加载因子
HashMap也不安全，所以公司中也不会用
方式1:Collections.synchronizedMap(new HashSet<>());
2.new ConcurrentHashMap<>();
5.Callable接口的使用
有返回值可以抛出异常，相比Runnable接口的优势
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class CallableTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
// new Thread(new Runnable()).start();
// new Thread(new FutureTask<V>()).start();
// new Thread(new FutureTask<V>(Callable)).start();
MyThread thread = new MyThread();
FutureTask futureTask = new FutureTask(thread);
new Thread(futureTask, "A").start();
Integer o = (Integer) futureTask.get();// get()方法可能会产生阻塞，把他放到最后或者使用异步通信
System.out.println(o);
}
}
class MyThread implements Callable<Integer> {
@Override
public Integer call() throws Exception {
System.out.println("call()");
return 1024;
}
}
6.常用的辅助类
6.1 CountDownLatch
import java.util.concurrent.CountDownLatch;
public class CountDownLatchDemo {
public static void main(String[] args) throws InterruptedException {
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("关门");
}
}
6.2 CyclicBarrier
累加计数器
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class CyclicBarrierDemo {
public static void main(String[] args) {
CyclicBarrier cyclicBarrier = new CyclicBarrier(7, ()->{
System.out.println("召唤神龙");
});
for (int i = 0; i <= 6; i++) {
final int temp = i; // 操作i需要这样做
new Thread(()->{
System.out.println(Thread.currentThread().getName() + "收集" + temp);
try {
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
System.out.println("???");
}).start();
}
}
}
6.3 Semaphore（信号量）
限流
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
public class SemaphoreDemo {
public static void main(String[] args) {
Semaphore semaphore = new Semaphore(3);
for (int i = 0; i < 6; i++) {
new Thread(() -> {
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();
}
}, String.valueOf(i)).start();
}
}
}
7.阻塞队列
7.1 BlockingQueue的API
| 方式 | 抛出异常 | 有返回值 | 阻塞等待 | 超时等待 |
|---|---|---|---|---|
| 添加 | add | offer//返回false | put | offer("a", 2, TimeUnit.SECONDS) |
| 删除 | remove | poll//返回null | take | Poll(2, TimeUnit.SECONDS) |
| 检测队首元素 | element | peek |
7.2 SynchronousQueue
没有容量，进去一个必须出来才能进入，大小固定为1
put take
8.线程池
程序占用系统的资源，为了优化资源的使用==>池化技术，比如线程池、内存池、对象池、连接池（创建销毁十分浪费资源）
池化技术：事先准备好一些资源，有人要用就拿
线程池的好处：
- 降低资源的消耗，提高速度
- 线程复用，可以控制最大并发数，管理线程
8.1 Executors类的方法
注意：
- 不能使用Executors工具类创建，因为默认值是21亿左右的intmax
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Pool {
public static void main(String[] args) {
//ExecutorService threadPool = Executors.newSingleThreadExecutor();//单个
ExecutorService threadPool = Executors.newFixedThreadPool(5);//固定大小
//ExecutorService threadPool = Executors.newCachedThreadPool();//尽量满足的大小
try {
for (int i = 0; i < 10; i++) {
//使用线程池创建线程
threadPool.execute(()->{
System.out.println(Thread.currentThread().getName() + " ok");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
threadPool.shutdown();//使用完一定要关闭
}
}
}
8.2 参数
//具体实现：
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.acc = System.getSecurityManager() == null ?
null :
AccessController.getContext();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
拒绝策略默认：
- AbortPolicy 不处理并抛出异常
- CallerRunsPolicy 哪里来的回哪去
- DiscardPolicy 不处理不抛出异常
- DiscardOldestPolicy 队列满了，尝试去和最早的竞争，不抛出异常
如何选择最大线程：
- cpu密集型 几核
Runtime.getRuntime().availableProcessors();
- io密集型 大型任务io十分占用资源，大于这个任务数即可
9.ForkJoin
并行执行任务，提高效率，大数据量
大数据： Map Reduce 把大任务拆成小任务
特点：工作窃取
里面维护的都是双端队列
import java.util.concurrent.RecursiveTask;
public class ForkJoin extends RecursiveTask<Long> {
private Long start;
private Long end;
private Long temp = 10000L;
public ForkJoin(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 = (start + end) / 2;
ForkJoin task1 = new ForkJoin(start, middle);
task1.fork(); // 拆分任务，把任务压入线程队列
ForkJoin task2 = new ForkJoin(middle + 1, end);
task2.fork();
return task1.join() + task2.join();
}
}
}
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();
test2();
test3();
}
public static void test1() {
long start = System.currentTimeMillis();
Long sum = 0L;
for (Long i = 1L; i < 10_0000_0000L; i++) {
sum += i;
}
long end = System.currentTimeMillis();
System.out.println(end - start);
}
public static void test2() throws ExecutionException, InterruptedException {
long start = System.currentTimeMillis();
ForkJoinPool forkJoinPool = new ForkJoinPool();
ForkJoinTask<Long> task = new ForkJoin(0L, 10_0000_0000L);
ForkJoinTask<Long> submit = forkJoinPool.submit(task);
Long sum = submit.get();
long end = System.currentTimeMillis();
System.out.println(end - start);
}
public static void test3() {
long start = System.currentTimeMillis();
// stream并行流
LongStream.rangeClosed(0L, 10_0000_0000L).parallel().reduce(0, Long::sum);
long end = System.currentTimeMillis();
System.out.println(end - start);
}
}
10.异步回调
eg.Ajax
11.Volatile关键字
Volatile是Java虚拟机提供的轻量级的同步机制
- 保证可见性
- 不保证原子性
- 禁止指令重排
11.1 什么是JMM
JMM--java内存模型，是一种概念，约定。
关于JMM的一些同步的约定：
-
线程解锁前，必须把共享变量 立刻 刷回
-
线程加锁前，必须读取主存中的最新值到工作内存中
-
加锁和解锁是同一把锁
主存，工作内存
内存交互操作
内存交互操作有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操作之前，必须把此变量同步回主内存
问题：主内存的值发生了改变，工作的线程不知道？
11.2 volatile三大特性
可见性：
import java.util.concurrent.TimeUnit;
public class JMMDemo {
//不加volatile程序就会死循环
//保证可见性
private volatile static int num = 0;
public static void main(String[] args) throws InterruptedException {
new Thread(()-> {
while(num==0) {}
}).start();
TimeUnit.SECONDS.sleep(1);
num = 1;
System.out.println(num);
}
}
不保证原子性：（原子性：不可分割，线程A执行任务不能被打扰，要么同时成功，要么同时失败）
加不加关键字，都每次结果不一样：
public class JMMDemo {
private volatile static int num = 0;
public static void add() {num++;}
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 20; i++) {
new Thread(()->{
for (int j = 0; j < 1000; j++) {
add();
}
}).start();
}
while(Thread.activeCount() > 2) { // main gc
Thread.yield();
}
System.out.println(Thread.currentThread().getName() +" : "+num);
}
}
如果不加lock和synchronized，怎么保证原子性：
javap -c class文件看底层：num++不是一个原子性操作
使用原子类，解决原子性问题，比lock等消耗资源小
private volatile static AtomicInteger num = new AtomicInteger();
public static void add() {num.getAndIncrement();} // +1方法，底层用CAS
这些类的底层直接和操作系统挂钩
禁止指令重排：
指令重排：计算机并不是按照写的代码进行执行
源代码--编译器优化的重排--指令并行也可能重排--内存系统也会重排--执行
int x = 1;
int y = 2;
x = x + 5;
y = x*x;
1234 2134 1324
4123？no，考虑数据之间的依赖性
| 线程A | 线程B |
|---|---|
| x=a | y=b |
| b=1 | a=2 |
xy都等于0，但如果指令重排，xy的值就变了
虽然指令重排很少发生，但还是有可能的。
volatile利用如下特性：
内存屏障，cpu指令。作用：
- 保证特定操作的执行顺序
- 保证某些变量的内存可见性
11.3 单例模式
饿汉式 DCL懒汉式
构造器私有
如果不加DCL，每次新建的对象数量不一定
需要避免指令重排，使用volatile，如果132，下一个直接返回对象，但还是空的
通过反射还可以破坏单例模式
在构造器锁避免：
如果注释掉getinstance创建对象，直接new了两个对象，又破坏了
使用标志位：
但反射又能破坏私有变量...
解决：
enum本身也是一个Class类，规定enum不可以newinstance
12.CAS
什么是CAS：compareAndSet()方法，比较当前工作内存中的值和主内存的值，如果这个值是期望的，执行操作；如果不是一直循环，循环会耗时
getAndIncrement()也就是++操作
内存地址偏离值
Unsafe类
java无法操作内存，而是调用c++（native方法）来操作内存。unsafe类--java的后门，可以通过这个类操作内存
ABA问题：
解决ABA问题，使用原子引用
13.各种锁的理解
13.1 公平锁、非公平锁
公平锁： 不能插队
非公平锁（默认）：比如3h的线程和3s的线程
13.2 可重入锁（递归锁）
拿到外面的锁，自动拿到了内部的锁
13.3 自旋锁
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
public class SpinLock {
AtomicReference<Thread> atomicReference = new AtomicReference<>();
// 加锁
public void myLock() {
Thread thread = Thread.currentThread();
System.out.println(Thread.currentThread().getName() + "get");
while(!atomicReference.compareAndSet(null, thread)){
}
}
// 解锁
public void myUnLock() {
Thread thread = Thread.currentThread();
System.out.println(Thread.currentThread().getName());
atomicReference.compareAndSet(thread, null);
}
}
class Test{
public static void main(String[] args) throws InterruptedException {
SpinLock lock = new SpinLock();
new Thread(()->{
lock.myLock();
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.myUnLock();
}
}, "T1").start();
TimeUnit.SECONDS.sleep(1);
new Thread(()->{
lock.myLock();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.myUnLock();
}
}, "T2").start();
}
}
T1 T2(自旋) T1 T2
13.4 死锁
import java.util.concurrent.TimeUnit;
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());
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lockB) {
System.out.println(Thread.currentThread().getName());
}
}
}
}
解决问题：
1.使用jps -l 定位进程号
2.使用jstack 进程号 查看堆栈信息
排查问题：
日志
堆栈信息！
浙公网安备 33010602011771号