笔记整理来源 B站UP主狂神说Java https://space.bilibili.com/95256449/
JUC并发多线程进阶
1、什么是JUC
源码+官方文档
JUC是 java util concurrent
面试高频问JUC~!
java.util 是Java的一个工具包~
业务:不会通过普通的线程代码 Thread 来实现
Runnable: 没有返回值、效率相比于Callable 相对较低!
2、线程和进程
进程:一个程序,QQ.exe Music.exe;数据+代码+pcb
一个进程可以包含多个线程,至少包含一个线程!
Java默认有几个线程?2个线程! main线程、GC线程
线程:开了一个进程Typora,写字,等待几分钟会进行自动保存(线程负责的)
对于Java而言:Thread、Runable、Callable进行开启线程的,我们之前。
提问?JAVA真的可以开启线程吗? 开不了的!
public synchronized void start() {
/**
* This method is not invoked for the main method thread or "system"
* group threads created/set up by the VM. Any new functionality added
* to this method in the future may have to also be added to the VM.
*
* A zero status value corresponds to state "NEW".
*/
if (threadStatus != 0)
throw new IllegalThreadStateException();
/* Notify the group that this thread is about to be started
* so that it can be added to the group's list of threads
* and the group's unstarted count can be decremented. */
group.add(this);
boolean started = false;
try {
start0();
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
/* do nothing. If start0 threw a Throwable then
it will be passed up the call stack */
}
}
}
//这是一个C++底层,Java是没有权限操作底层硬件的
private native void start0();
Java是没有权限去开启线程、操作硬件的(因为java运行在jvm上的),这是一个native的一个本地方法,它调用的底层的C++代码。
并发、并行
并发: 多线程操作同一个资源。
- CPU 只有一核,模拟出来多条线程。那么我们就可以使用CPU快速交替,来模拟多线程。
并行: 多个人一起行走
- CPU多核,多个线程可以同时执行。 我们可以使用线程池!
public class Test1 {
public static void main(String[] args) {
//获取cpu的核数
System.out.println(Runtime.getRuntime().availableProcessors());
}
}
并发编程的本质:充分利用CPU的资源!
线程有几个状态?
线程的状态:6个状态
public enum State {
NEW, //新生
RUNNABLE, //运行
BLOCKED, //阻塞
WAITING, //等待 死死的等
TIMED_WAITING, //超时等待
TERMINATED; //终止
}
wait/sleep的区别
1、来自不同的类
wait => Object
sleep => Thread
一般情况企业中使用休眠是:
TimeUnit.DAYS.sleep(1); //休眠1天
TimeUnit.SECONDS.sleep(1); //休眠1s
2、关于锁的释放
wait 会释放锁;
sleep睡觉了,不会释放锁;
3、使用的范围是不同的
wait 必须在同步代码块中;
sleep 可以在任何地方睡;
3、Lock锁(重点)
传统的Synchronized
/**
* 真正的多线程开发,公司开发降低耦合性
* 线程就是一个单独的资源类,没有任何的附属操作!
*/
public class SaleTicketDemo01 {
public static void main(String[] args) {
//多线程操作
//并发:多线程操作同一个资源类,把资源类丢入线程
Ticket ticket = new Ticket();
//@FunctionalInterface 函数式接口 jdk1.8之后 lambda表达式 (参数)->{代码}
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();
}
}
//资源类
//属性+方法
//oop 面向对象 不在是继承或者是实现什么接口 类变得很纯粹 降低耦合性
class Ticket{
private int number=50;
//卖票的方式
// synchronized 本质:队列 排队,锁
public synchronized void sale(){
if(number>0){
System.out.println(Thread.currentThread().getName()+" 卖出了第"+number+" 张票,剩余:"+--number+" 张票");
}
}
}
Lock接口
公平锁: 十分公平, 必须先来后到~;
非公平锁: 十分不公平,可以插队;(默认为非公平锁)
package com.liu;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class SaleTicketDemo02 {
public static void main(String[] args) {
Ticket2 ticket = new Ticket2();
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();
}
}
//lock三部曲
//1、 Lock lock=new ReentrantLock();
//2、 lock.lock() 加锁
//3、 finally=> 解锁:lock.unlock();
class Ticket2{
private int number=50;
Lock lock=new ReentrantLock();
//卖票的方式
// 使用Lock 锁
public void sale(){
//加锁
lock.lock();
try {
//业务代码
if(number>0){
System.out.println(Thread.currentThread().getName()+" 卖出了第"+number+" 张票,剩余:"+--number+" 张票");
}
}catch (Exception e) {
e.printStackTrace();
}
finally {
//解锁
lock.unlock();
}
}
}
Synchronized 和 Lock区别
-
1、Synchronized 内置的Java关键字,Lock是一个Java类
-
2、Synchronized(自动的) 无法判断获取锁的状态,Lock可以判断
-
3、Synchronized 会自动释放锁,Lock必须要手动加锁和手动释放锁!可能会遇到死锁
-
4、Synchronized 线程1(获得锁–>阻塞)、线程2(等待);
Lock 就不一定会一直等待下去,Lock会有一个trylock去尝试获取锁,不会造成长久的等待。
-
5、Synchronized 可重入锁,不可以中断的,非公平的;
Lock 可重入锁,可以判断锁,可以自己设置公平锁和非公平锁;
-
6、Synchronized 适合锁少量的代码同步问题
Lock 适合锁大量的同步代码;
锁到底是什么? 如何判断锁的是谁?
4、生产者和消费者问题!
面试高频:单例模式、八大排序算法、生产者和消费者、死锁
Synchronized wait notify可以实现,该方法是传统版本;
Synchronized版本
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;
//+1
public synchronized void increment() throws InterruptedException {
if(number!=0){
//等待操作
this.wait();
}
number++;
System.out.println(Thread.currentThread().getName()+"=>"+number);
//通知其他线程 我+1完毕了
this.notifyAll();
}
//-1
public synchronized void decrement() throws InterruptedException {
if(number==0){
//等待操作
this.wait();
}
number--;
System.out.println(Thread.currentThread().getName()+"=>"+number);
//通知其他线程 我-1完毕了
this.notifyAll();
}
}
问题存在,A线程B线程,现在如果我有四个线程A B C D!
解决方案: if 改为while即可,防止虚假唤醒
这样就不存在问题了
什么是虚假唤醒
假如被阻塞的多个线程都被唤醒,但实际情况是被唤醒的线程中有一部分线程是不应该被唤醒的,那么对于这些不应该被唤醒的线程而言就是虚假唤醒
为什么会存在虚假唤醒
Object.wait会自动释放锁,并请求操作系统挂起当前线程,从而使得其他线程能够获取这个锁并修改对象的状态
因为if判断在值发生改变的时候,它不会停,只判断一次
而 while 在值发生改变的时候 会进行等待 不会出现两个线程同时去操作我们的属性值
if和while的区别
- while是用来做循环的,也就是说只要条件满足,就会执行一次循环体,执行完以后会再判断一次条件,如果满足条件,还会再执行一次,终而复始,除非你在循环中对条件进行了改变才会从循环中跳出来。
- if只做一次判断,条件不满足就不执行,满足就执行一次,执行完就往下执行,不会再回过头来继续执行。
JUC版本的生产者和消费者问题
await、signal 替换 wait、notify
通过Lock找到Condition
package com.liu;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class B {
public static void main(String[] args) {
Data2 data = new Data2();
new Thread(()->{
for(int i=0;i<10;i++) {
data.increment();
}
},"A").start();
new Thread(()->{
for(int i=0;i<10;i++) {
data.decrement();
}},"B").start();
new Thread(()->{
for(int i=0;i<10;i++) {
data.increment();
}
},"C").start();
new Thread(()->{
for(int i=0;i<10;i++) {
data.decrement();
}
},"D").start();
}
}
class Data2{
//数字 资源类
private int number = 0;
//lock锁
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
//+1
public void increment() {
lock.lock();
try{
//业务
while (number!=0){
//等待操作
condition.await();
}
number++;
System.out.println(Thread.currentThread().getName()+"=>"+number);
//通知其他线程 我+1完毕了
condition.signalAll();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
//-1
public void decrement() {
lock.lock();
try{
//业务
while (number==0){
//等待操作
condition.await();
}
number--;
System.out.println(Thread.currentThread().getName()+"=>"+number);
//通知其他线程 我+1完毕了
condition.signalAll();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
Condition的优势:精准的通知和唤醒的线程!
如果我们要指定通知的下一个进行顺序怎么办呢? 我们可以使用Condition来指定通知进程~
package com.liu;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* A 执行完 调用B
* B 执行完 调用C
* C 执行完 调用A
*/
public class C {
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 number = 1; //1A 2B 3C
public void printA(){
lock.lock();
try {
//业务 判断 -> 执行 -> 通知
while(number!=1){
//等待
condition1.await();
}
//操作
System.out.println(Thread.currentThread().getName()+",AAAAA");
//唤醒指定的线程
number=2;
condition2.signal(); // 唤醒2
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void printB(){
lock.lock();
try {
//业务 判断 -> 执行 -> 通知
while (number!=2){
condition2.await();
}
System.out.println(Thread.currentThread().getName()+",BBBBB");
//唤醒3
number=3;
condition3.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void printC(){
lock.lock();
try {
//业务 判断 -> 执行 -> 通知
while(number!=3){
condition3.await();
}
System.out.println(Thread.currentThread().getName()+",CCCCC");
//唤醒1
number=1;
condition1.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
5、八锁现象
八锁 就是关于锁的八个问题
如何判断锁的是谁!锁到底锁的是谁?
锁会锁住:对象、Class
深刻理解我们的锁
- 问题1:
package com.liu;
import java.util.concurrent.TimeUnit;
/*
* 八锁 就是关于锁的八个问题*/
public class Test1 {
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(){
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
}
结果是:先发短信,如何再打电话!
为什么? 是因为顺序在前吗?不, 这个答案是错误的!
- 问题2:
我们再来看:我们让发短信 延迟4s
public synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
现在结果是什么呢?
结果:还是先发短信,然后再打电话!
why?
原因:并不是顺序执行!是因为synchronized 锁的对象是方法的调用者!对于两个方法用的是同一个锁,谁先拿到谁先执行!另外一个则等待!
- 问题3:
如果我们添加一个普通方法,那么先执行哪一个呢?
package com.liu;
import java.util.concurrent.TimeUnit;
public class Test1 {
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.hello();
},"B").start();
}
}
class Phone{
public synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} 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秒去掉,那么就会顺序执行,先执行发短信然后再执行hello,原因应该是顺序执行的原因吧,不是太理解。
- 问题4:
如果我们使用的是两个对象,一个调用发短信,一个调用打电话,那么整个顺序是怎么样的呢?
package com.liu;
import java.util.concurrent.TimeUnit;
public class Test1 {
public static void main(String[] args) throws InterruptedException {
Phone phone = new Phone();
Phone phone1 = new Phone();
new Thread(()->{
phone.sendSms();
},"A").start();
TimeUnit.SECONDS.sleep(1);
new Thread(()->{
phone1.call();
},"B").start();
}
}
class Phone{
public synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
}
答案是:先打电话,后发短信。原因:在发短信方法中延迟了4s,又因为synchronized锁的是对象,但是我们这使用的是两个对象,所以每个对象都有一把锁,所以不会造成锁的等待。正常执行
- 问题5,6:
如果我们把synchronized的方法加上static变成静态方法!那么顺序又是怎么样的呢?
(1)我们先来使用一个对象调用两个方法!
答案是:先发短信,后打电话
(2)如果我们使用两个对象调用两个方法!
答案是:还是先发短信,后打电话
原因是什么呢? 为什么加了static就始终前面一个对象先执行呢!为什么后面会等待呢?
原因是:对于static静态方法来说,类一加载就有了,对于整个类Class来说只有一份,对于不同的对象使用的是同一份方法,相当于这个方法是属于这个类的,如果静态static方法使用synchronized锁定,那么这个synchronized锁会锁住整个Class对象!不管多少个对象,对于静态的锁都只有一把锁,谁先拿到这个锁就先执行,其他的进程都需要等待!
- 问题7:
如果我们使用一个静态同步方法、一个同步方法、一个对象调用顺序是什么?
package com.liu;
import java.util.concurrent.TimeUnit;
public class Test2 {
public static void main(String[] args) throws InterruptedException {
Phone1 phone = new Phone1();
new Thread(()->{
phone.sendSms();
},"A").start();
TimeUnit.SECONDS.sleep(1);
new Thread(()->{
phone.call();
},"B").start();
}
}
class Phone1{
public static synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
}
明显答案是:先打电话,后发短信了。
因为一个锁的是Class类模板,一个锁的是对象调用者。后面那个打电话不需要等待发短信,直接运行就可以了。
- 问题8:
如果我们使用一个静态同步方法、一个同步方法、两个对象调用顺序是什么呢?
package com.liu;
import java.util.concurrent.TimeUnit;
public class Test2 {
public static void main(String[] args) throws InterruptedException {
Phone1 phone = new Phone1();
Phone1 phone1 = new Phone1();
new Thread(()->{
phone.sendSms();
},"A").start();
TimeUnit.SECONDS.sleep(1);
new Thread(()->{
phone1.call();
},"B").start();
}
}
class Phone1{
public static synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
}
当然答案是:先打电话、后发短信!
因为两个对象,一样的原因:两把锁锁的不是同一个东西,所以后面的第二个对象不需要等待第一个对象的执行。
小结
-
new 出来的 this 是具体的一个对象
-
static Class 是唯一的一个模板
6、集合类不安全
List不安全
我们来看一下List这个集合类:
//java.util.ConcurrentModificationException 并发修改异常!
public class ListTest {
public static void main(String[] args) {
List<Object> arrayList = new ArrayList<>();
for(int i=1;i<=100;i++){
new Thread(()->{
arrayList.add(UUID.randomUUID().toString().substring(0,5));
System.out.println(arrayList);
},String.valueOf(i)).start();
}
}
}
会造成 java.util.ConcurrentModificationException 并发修改异常!
ArrayList 在并发情况下是不安全的!
解决方案:
1、切换成Vector就是线程安全的啦!
public class ListTest {
public static void main(String[] args) {
List<Object> arrayList = new Vector<>();
}
}
Vector的add方法,Vector比ArrayList更早出现,所以Vector只是其中一种解决办法
2、使用工具类 Collections.synchronizedList(new ArrayList<>());
public class ListTest {
public static void main(String[] args) {
List<Object> arrayList = Collections.synchronizedList(new ArrayList<>());
}
}
3、使JUC中的包:List arrayList = new CopyOnWriteArrayList<>();
public class ListTest {
public static void main(String[] args) {
List<Object> arrayList = new CopyOnWriteArrayList<>();
}
}
CopyOnWriteArrayList:写入时复制! COW 计算机程序设计领域的一种优化策略 ,提高效率
多个线程调用的时候,list,读取的时候,是固定的,写入(存在覆盖操作);在写入的时候避免覆盖,造成数据错乱的问题;
CopyOnWriteArrayList比Vector厉害在哪里?
Vector 底层是使用synchronized关键字来实现的:效率特别低下。
CopyOnWriteArrayList 使用的是Lock锁,效率会更加高效!
Set不安全
和List、Set同级的还有一个BlockingQueue 阻塞队列;
Set和List同理可得: 多线程情况下,普通的Set集合是线程不安全的;
解决方案还是两种:
- 使用Collections工具类的synchronized包装的Set类
- 使用 new CopyOnWriteArraySet() 写入复制的JUC解决方案
public class SetTest {
public static void main(String[] args) {
// Set<String> hashSet = Collections.synchronizedSet(new HashSet<>()); //解决方案1
Set<String> hashSet = new CopyOnWriteArraySet<>(); //解决方案2
for (int i = 1; i < 100; i++) {
new Thread(()->{
hashSet.add(UUID.randomUUID().toString().substring(0,5));
System.out.println(hashSet);
},String.valueOf(i)).start();
}
}
}
HashSet底层是什么?
hashSet底层就是一个HashMap;
public HashSet() {
map = new HashMap<>();
}
//add 本质其实就是一个map的key,map的key是无法重复的,所以使用的就是map存储
//hashSet 就是使用了hashmap key不能重复的原理
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
//PRESENT是什么? 是一个常量 不会改变的常量 无用的占位
private static final Object PRESENT = new Object();
Map不安全
回顾map的基本操作:
//map 是这样用的吗? 不是,工作中不使用这个
//默认等价什么? new HashMap<>(16,0.75);
Map<String, String> map = new HashMap<>();
//public HashMap(int initialCapacity, float loadFactor)
//初始化容量、加载因子
同样的HashMap基础类也存在并发修改异常!
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
for (int i = 1; i < 100; i++) {
new Thread(()->{
map.put(Thread.currentThread().getName(),UUID.randomUUID().toString().substring(0,5));
System.out.println(map);
},String.valueOf(i)).start();
}
}
解决方案:
- 使用Collections.synchronizedMap(new HashMap<>());处理;
- 使用new ConcurrentHashMap进行并发处理
研究ConcurrentHashMap底层原理:
这里我们可以直接去研究一下,这个也是相当重要的。参考:https://blog.csdn.net/weixin_43185598/article/details/87938882
7、Callable(简单)
结论:Callable
1、可以有返回值;
2、可以抛出异常;
3、方法不同,run()/call()
传统使用线程方式:
public class CallableTest {
public static void main(String[] args) {
for (int i = 1; i < 10; i++) {
new Thread(new MyThread()).start();
}
}
}
class MyThread implements Runnable{
//不建议使用
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}
使用Callable进行多线程操作:
但是如何使用呢?
Callable怎么放入到Thread里面呢?
看JDK api文档:
在Runnable里面有一个叫做FutureTask的实现类,我们进去看一下。
这样我们就可以先把Callable 放入到FutureTask中, 然后再把FutureTask (因为它继承了Runnable)放入到Thread就可以了。
public class CallableTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
for (int i = 1; i < 10; i++) {
// new Thread(new Runnable()).start();
// new Thread(new FutureTask<>( Callable)).start();
MyThread thread= new MyThread();
//适配类:FutureTask
FutureTask<String> futureTask = new FutureTask<>(thread);
//放入Thread使用
new Thread(futureTask,String.valueOf(i)).start();
//获取Callable的返回值 就是我们 return 的值
String s = futureTask.get();
System.out.println("返回值:"+ s);
}
}
}
class MyThread implements Callable<String> {
@Override
public String call() throws Exception {
System.out.println("Call:"+Thread.currentThread().getName());
return "String"+Thread.currentThread().getName();
}
}
这样我们就可以使用Callable来进行多线程编程了,并且我们发现可以有返回值,并且可以抛出异常
注意两个重点:
8、常用的辅助类(必会!)
8.1 CountDownLatch
//这是一个计数器 减法
public class CountDownLatchDemo {
public static void main(String[] args) throws InterruptedException {
//总数是6 倒计时
CountDownLatch countDownLatch = new CountDownLatch(6);
for (int i = 1; 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");
}
}
主要方法:
-
countDown 减一操作;
-
await 等待计数器归零。
-
await 等待计数器为0,就唤醒,再继续向下运行。
8.2 CyclickBarrier
其实就是一个加法计数器;
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; //我们在lambda表达式中不能使用到i ,所以采用final,jdk1.8之后就不用加final了
new Thread(()->{
System.out.println(Thread.currentThread().getName()+" 收集了第 {"+ finalI+"} 颗龙珠");
try {
cyclicBarrier.await(); //加法计数 等待
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}).start();
}
}
}
8.3 Semaphore
相当于通行证
Semaphore:信号量
抢车位:
3个车位 6辆车:
public class SemaphoreDemo {
public static void main(String[] args) {
//停车位为3个
Semaphore semaphore = new Semaphore(3);
for (int i = 1; i <= 6; i++) {
int finalI = i;
new Thread(()->{
try {
semaphore.acquire(); //得到
//抢到车位
System.out.println(Thread.currentThread().getName()+" 抢到了车位{"+ finalI +"}");
TimeUnit.SECONDS.sleep(2); //停车2s
System.out.println(Thread.currentThread().getName()+" 离开车位");
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
semaphore.release();//释放
}
},String.valueOf(i)).start();
}
}
}
原理:
semaphore.acquire() 获得资源,如果资源已经使用完了,就会阻塞,然后等待资源释放后再进行使用!
semaphore.release() 释放,会将当前的信号量释放+1,然后唤醒等待的线程!
作用: 多个共享资源互斥的使用! 并发限流,控制最大的线程数!
9、读写锁
ReadWriteLock 为了提高工作效率,提高程序性能
先对于不加锁的情况:
如果我们做一个我们自己的cache缓存。分别有写入操作、读取操作;
我们采用五个线程去写入,使用十个线程去读取。
我们来看一下这个的效果,如果我们不加锁的情况!
package com.liu;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/*
* */
public class ReadWriteLockDemo {
public static void main(String[] args) {
MyCache_ReadWriteLock mycache = new MyCache_ReadWriteLock();
//开启5个线程 写入数据
for (int i = 1; i <=5 ; i++) {
int finalI = i;
new Thread(()->{
mycache.put(String.valueOf(finalI),String.valueOf(finalI));
}).start();
}
//开启10个线程去读取数据
for (int i = 1; i <=10 ; i++) {
int finalI = i;
new Thread(()->{
String o = mycache.get(String.valueOf(finalI));
}).start();
}
}
}
/*
* 自定义缓存
* */
class MyCache_ReadWriteLock{
private volatile Map<String,String> map=new HashMap<>(); //volatile 保证原子性
public void put(String key,String value){
//写入 存
System.out.println(Thread.currentThread().getName()+" 线程 开始写入");
map.put(key, value);
System.out.println(Thread.currentThread().getName()+" 线程 写入OK");
}
public String get(String key){
//得到 读
System.out.println(Thread.currentThread().getName()+" 线程 开始读取");
String o = map.get(key);
System.out.println(Thread.currentThread().getName()+" 线程 读取OK");
return o;
}
}
所以如果我们不加锁的情况,多线程的读写会造成数据不可靠的问题。
我们也可以采用synchronized这种重量锁和轻量锁 lock去保证数据的可靠。
但是这次我们采用更细粒度的锁:ReadWriteLock 读写锁来保证
/*
* 独占锁(写锁) 一次只能被一个线程占有,
* 共享锁(读锁) 多个线程可以同时占有
* */
public class ReadWriteLockDemo {
public static void main(String[] args) {
MyCache_ReadWriteLock mycache = new MyCache_ReadWriteLock();
for (int i = 1; i <=5 ; i++) {
int finalI = i;
new Thread(()->{
mycache.put(String.valueOf(finalI),String.valueOf(finalI));
}).start();
}
for (int i = 1; i <=10 ; i++) {
int finalI = i;
new Thread(()->{
String o = mycache.get(String.valueOf(finalI));
}).start();
}
}
}
class MyCache_ReadWriteLock{
private volatile Map<String,String> map=new HashMap<>();
//使用读写锁
private ReadWriteLock readWriteLock=new ReentrantReadWriteLock();
//普通锁 对比
//private Lock lock=new ReentrantLock();
//写入的时候只希望同时只有一个线程去写
public void put(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 String get(String key){
//加锁
String o="";
readWriteLock.readLock().lock();
try {
//得到 读
System.out.println(Thread.currentThread().getName()+" 线程 开始读取");
o = map.get(key);
System.out.println(Thread.currentThread().getName()+" 线程 读取OK");
} catch (Exception e) {
e.printStackTrace();
} finally {
readWriteLock.readLock().unlock();
}
return o;
}
}
10、阻塞队列
队列
阻塞队列jdk1.8文档解释:
BlockingQueue
blockingQueue 是Collection的一个子类,他不是一个新的东西,它和set,list相似;
整个阻塞队列的家族如下:
Queue以下实现的有Deque(双端队列)、AbstaractQueue(非阻塞队列)、BlockingQueue(阻塞队列);
BlockingQueue以下有Link链表实现的阻塞队列、也有Array数组实现的阻塞队列
什么情况我们会使用 阻塞队列呢?
多线程并发处理、线程池!
如何使用阻塞队列呢?
操作:添加元素、移除元素
但是实际我们要学的有:
四组API
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;
public class test1 {
public static void main(String[] args) throws InterruptedException {
test4();
//test2();
}
/**
* 抛出异常
*/
public static void test1(){
//需要初始化队列的大小
ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
//添加元素
System.out.println(blockingQueue.add("a")); //true
System.out.println(blockingQueue.add("b"));
System.out.println(blockingQueue.add("c"));
//System.out.println(blockingQueue.add("d"));
//抛出异常:java.lang.IllegalStateException: Queue full
//查看队首元素
System.out.println("=====================");
System.out.println(blockingQueue.element()); //a
System.out.println("=====================");
//移除元素
System.out.println(blockingQueue.remove()); //a
System.out.println(blockingQueue.remove()); //b
System.out.println(blockingQueue.remove()); //c
//System.out.println(blockingQueue.remove());
//如果多移除一个
//这也会造成 java.util.NoSuchElementException 抛出异常
}
//=======================================================================================
/**
* 不抛出异常,有返回值
*/
public static void test2(){
ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
//添加元素
System.out.println(blockingQueue.offer("a")); //true
System.out.println(blockingQueue.offer("b"));
System.out.println(blockingQueue.offer("c"));
//添加 一个不能添加的元素 使用offer只会返回false 不会抛出异常
System.out.println(blockingQueue.offer("d")); //false
//弹出
System.out.println(blockingQueue.poll()); //a
System.out.println(blockingQueue.poll()); //b
System.out.println(blockingQueue.poll()); //c
//弹出 如果没有元素 只会返回null 不会抛出异常
System.out.println(blockingQueue.poll()); //null
}
//=======================================================================================
/**
* 等待 一直阻塞
*/
public static void test3() throws InterruptedException {
ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
//一直阻塞 不会返回
blockingQueue.put("a");
blockingQueue.put("b");
blockingQueue.put("c");
//blockingQueue.put("d");
//如果队列已经满了, 再进去一个元素 这种情况会一直等待这个队列 什么时候有了位置再进去,程序不会停止
System.out.println(blockingQueue.take());
System.out.println(blockingQueue.take());
System.out.println(blockingQueue.take());
//如果我们再来移除一个 这种情况也会等待,程序会一直运行 阻塞
System.out.println(blockingQueue.take());
}
//=======================================================================================
/**
* 等待 超时阻塞
* 这种情况也会等待队列有位置 或者有产品 但是会超时结束
*/
public static void test4() throws InterruptedException {
ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
blockingQueue.offer("a");
blockingQueue.offer("b");
blockingQueue.offer("c");
System.out.println("开始等待");
blockingQueue.offer("d",2, TimeUnit.SECONDS); //超时时间2s 等待如果超过2s就结束等待
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("结束等待");
}
}
SynchronousQueue同步队列
同步队列 没有容量,也可以视为容量为1的队列;
进去一个元素,必须等待取出来之后,才能再往里面放入一个元素;
put方法 和 take方法
Synchronized 和 其他的BlockingQueue 不一样 它不存储元素;
put了一个元素,就必须从里面先take出来,否则不能再put进去值!
并且SynchronousQueue 的take是使用了lock锁保证线程安全的。
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;
/**
* 同步队列
*/
public class SynchronousQueueDemo {
public static void main(String[] args) {
BlockingQueue<String> synchronousQueue = new SynchronousQueue<>();
//研究一下 如果判断这是一个同步队列
//使用两个进程
// 一个进程 放进去
// 一个进程 拿出来
new Thread(()->{
try {
System.out.println(Thread.currentThread().getName()+" Put 1");
synchronousQueue.put("1");
System.out.println(Thread.currentThread().getName()+" Put 2");
synchronousQueue.put("2");
System.out.println(Thread.currentThread().getName()+" Put 3");
synchronousQueue.put("3");
} catch (InterruptedException e) {
e.printStackTrace();
}
},"T1").start();
new Thread(()->{
try {
System.out.println(Thread.currentThread().getName()+" Take "+synchronousQueue.take());
//TimeUnit.SECONDS.sleep(3);
System.out.println(Thread.currentThread().getName()+" Take "+synchronousQueue.take());
//TimeUnit.SECONDS.sleep(3);
System.out.println(Thread.currentThread().getName()+" Take "+synchronousQueue.take());
} catch (InterruptedException e) {
e.printStackTrace();
}
},"T2").start();
}
}
11、线程池(重点)
线程池:三大方法、七大参数、四种拒绝策略
池化技术
程序的运行,本质:占用系统的资源!我们需要去优化资源的使用 ===> 池化技术
线程池、JDBC的连接池、内存池、对象池 等等。。。。
资源的创建、销毁十分消耗资源
池化技术:事先准备好一些资源,如果有人要用,就来我这里拿,用完之后还给我,以此来提高效率。
线程池的好处:
1、降低资源的消耗;
2、提高响应的速度;
3、方便管理;
线程复用、可以控制最大并发数、管理线程;
三大方法
- ExecutorService threadPool = Executors.newSingleThreadExecutor(); //单个线程
- ExecutorService threadPool2 = Executors.newFixedThreadPool(5); //创建一个固定的线程池的大小
- ExecutorService threadPool3 = Executors.newCachedThreadPool(); //可伸缩的,可改变的
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//工具类 Executors 三大方法;
public class Demo01 {
public static void main(String[] args) {
// Executors工具类
//ExecutorService threadPool = Executors.newSingleThreadExecutor();//单个线程
//ExecutorService threadPool = Executors.newFixedThreadPool(5); //创建一个固定的线程池的大小
ExecutorService threadPool = Executors.newCachedThreadPool(); //可伸缩的
//线程池用完必须要关闭线程池
try {
for (int i = 1; i <=10 ; i++) {
// 传统方式
// new Thread().start();
//使用了线程池后,通过线程池创建线程
threadPool.execute(()->{
System.out.println(Thread.currentThread().getName()+ " ok");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//线程池用完要关闭
threadPool.shutdown();
}
}
}
Single
Fixed
Cached
七大参数
源码分析
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1, //只有一
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
return new ThreadPoolExecutor(nThreads, nThreads, //传递的参数
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>(),
threadFactory);
}
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE, //Integer.MAX_VALUE 约等于21亿
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>(),
threadFactory);
}
本质:三种方法都是开启的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;
}
阿里巴巴的Java操作手册中明确说明:对于Integer.MAX_VALUE初始值较大,所以一般情况我们要使用底层的ThreadPoolExecutor来创建线程池。
业务图
手动创建线程池
import java.util.concurrent.*;
public class Demo01 {
public static void main(String[] args) {
// 自定义线程池!工作中使用
ExecutorService threadPool = new ThreadPoolExecutor(2, // 七大参数一定能要熟悉
5,
3,
TimeUnit.SECONDS,
new LinkedBlockingDeque<>(3),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy()); // 默认的拒绝策略,银行满了但是还有人进来,不处理这个人,并且抛出异常 和阻塞队列的四种api相似
try {
//最大承载:队列容量大小+maxPoolSize
for (int i = 1; i <=100 ; i++) {
threadPool.execute(()->{
System.out.println(Thread.currentThread().getName()+ " ok");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
threadPool.shutdown();
}
}
}
四种拒绝策略
(1)new ThreadPoolExecutor.AbortPolicy(): //该拒绝策略为:银行满了,还有人进来,不处理这个人的,并抛出异常
超出最大承载,就会抛出异常:队列容量大小+maxPoolSize
(2)new ThreadPoolExecutor.CallerRunsPolicy(): //该拒绝策略为:哪来的去哪里 main线程进行处理
(3)new ThreadPoolExecutor.DiscardPolicy(): //该拒绝策略为:队列满了,丢掉异常,不会抛出异常。
(4)new ThreadPoolExecutor.DiscardOldestPolicy(): //该拒绝策略为:队列满了,尝试去和最早的进程竞争,不会抛出异常
如何设置线程池的最大大小?
CPU密集型和IO密集型!(调优!)
1、CPU密集型:电脑的核数是几核就选择几;选择maximunPoolSize的大小
我们可以使用代码来来获取逻辑处理器数量。
于是cpu密集型的写法如下:
2、I/O密集型:
在程序中有15个大型任务,io十分占用资源;
I/O密集型就是判断我们程序中十分耗I/O的线程数量,大约是最大耗I/O线程数的一倍到两倍之间
12、四大函数式接口(必需掌握)
新时代的程序员:lambda表达式、链式编程、函数式接口、Stream流式计算
函数式接口
函数式接口:只有一个方法的接口
@FunctionalInterface
public interface Runnable {
public abstract void run();
}
// 超级多的@FunctionalInterface
// 简化编程模型,在新版本的框架底层大量应用
// foreach()的参数也是一个函数式接口,消费者类的函数式接口
代码测试:
Function函数型接口
import java.util.function.Function;
/**
* Function函数型接口,有一个输入参数,一个输出
* 只要是 函数型接口 可以 用 lambda表达式简化
*/
public class Demo01 {
public static void main(String[] args) {
//工具类:输出输入的值
// Function function = new Function<String,String>() {
// //匿名类
// @Override
// public String apply(String o) {
// return o;
// }
// };
//lambda表达式简化
Function<String,String> function = (str) ->{
return str;};
System.out.println(function.apply("abc"));
}
}
Predicate 断定型接口
import java.util.function.Predicate;
/**
* 断定型接口:有一个输入参数,返回值只能是 布尔值!
*/
public class Demo02 {
public static void main(String[] args) {
//可以判断字符串是否为空
Predicate<String> predicate = (str)->{
return str.isEmpty();};
System.out.println(predicate.test("11"));
System.out.println(predicate.test(""));
}
}
Consummer 消费型接口
import java.util.function.Consumer;
/**
* 消费型接口 没有返回值!只有输入!
*/
public class Demo03 {
public static void main(String[] args) {
Consumer<String> consumer = (str)->{
System.out.println(str);
};
consumer.accept("abc");
}
}
Supplier 供给型接口
import java.util.function.Supplier;
/**
* 供给型接口,只返回,不输入
*/
public class Demo04 {
public static void main(String[] args) {
Supplier<String> supplier = ()->{
return "1024";};
System.out.println(supplier.get());
}
}
13、Stream流式计算
什么是Stream流式计算?
大数据:存储+计算!
存储:集合、MySQL 本质就是存储东西的
计算:都是流式计算~
=== 链式编程 ===
import java.util.Arrays;
import java.util.List;
/**
* 题目要求
* 筛选用户
* 1、ID 必须是偶数
* 2、年龄大于23岁
* 3、用户名转换为大写
* 4、用户名字母倒者排序
* 5、只输出一个用户
*/
public class Test {
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);
User user6 = new User(6,"f",26);
//集合就是存储
List<User> list = Arrays.asList(user1, user2, user3, user4, user5, user6);
//第二种方法!! Arrays.asList和new ArrayList<>()的区别!!!
// ArrayList<User> list1 = new ArrayList<>();
// list1.add(user1);
// list1.add(user2);
// list1.add(user3);
// list1.add(user4);
// list1.add(user5);
// list1.add(user6);
//System.out.println(list);
//System.out.println(list1);
//两个的输出结果相同
//[User(id=1, name=a, age=21), User(id=2, name=b, age=22), User(id=3, name=c, age=23), User(id=4, name=d, age=24), User(id=5, name=e, age=25), User(id=6, name=f, age=26)]
//[User(id=1, name=a, age=21), User(id=2, name=b, age=22), User(id=3, name=c, age=23), User(id=4, name=d, age=24), User(id=5, name=e, age=25), User(id=6, name=f, age=26)]
//计算交给流
//链式编程!!!!
list.stream() //将list转换成stream对象
.filter((u)->{
return u.getId()%2==0; }) //过滤用户,u会自动遍历
.filter((u)->{
return u.getAge()>23;}) //
.map((u)->{
return u.getName().toUpperCase();}) // 转换为大写
.sorted((uu1,uu2)->{
// 排序
return uu2.compareTo(uu1); // uu2对uu1排序 就是倒序
})
.limit(1)
.forEach(System.out::println);
}
}
14、ForkJoin
什么是ForkJoin?
ForkJoin 在JDK1.7,并行执行任务!提高效率~。在大数据量速率会更快!
大数据中:Map Reduce 核心思想->把大任务拆分为小任务!
ForkJoin 特点: 工作窃取!
实现原理是:双端队列!从上面和下面都可以去拿到任务进行执行!
如何使用ForkJoin?
- 1、通过ForkJoinPool来执行
- 2、计算任务 execute(ForkJoinTask<?> task)
- 3、计算类要去继承ForkJoinTask;
ForkJoin的计算类!
import java.util.concurrent.RecursiveTask;
public class ForkJoinDemo extends RecursiveTask<Long> {
private long star;
private long end;
//临界值
private long temp=1000000L;
public ForkJoinDemo(long star, long end) {
this.star = star;
this.end = end;
}
/**
* 计算方法
* @return Long
*/
@Override
protected Long compute() {
if((end-star)<temp){
Long sum = 0L;
for (Long i = star; i < end; i++) {
sum+=i;
}
// System.out.println(sum);
return sum;
}else {
//使用forkJoin 分而治之 计算
//计算平均值
long middle = (star+ end)/2;
ForkJoinDemo forkJoinDemoTask1 = new ForkJoinDemo(star, middle);
forkJoinDemoTask1.fork(); //拆分任务,把线程任务压入线程队列
ForkJoinDemo forkJoinDemoTask2 = new ForkJoinDemo(middle, end);
forkJoinDemoTask2.fork(); //拆分任务,把线程任务压入线程队列
long taskSum = forkJoinDemoTask1.join() + forkJoinDemoTask2.join();
return taskSum;
}
}
}
测试类!
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 star = System.currentTimeMillis();
long sum = 0L;
for (long i = 1; i <= 10_0000_0000; i++) {
sum+=i;
}
long end = System.currentTimeMillis();
System.out.println("sum="+sum+" 时间:"+(end-star));
//System.out.println(sum);
}
/**
* 使用ForkJoin
*/
public static void test2() throws ExecutionException, InterruptedException {
long star = System.currentTimeMillis();
ForkJoinPool forkJoinPool = new ForkJoinPool(); //通过ForkJoinPool来执行
ForkJoinTask<Long> task = new ForkJoinDemo(0L, 10_0000_0001L); //创建任务的对象
//forkJoinPool.execute(task); 执行任务 没有返回结果
ForkJoinTask<Long> submit = forkJoinPool.submit(task); //提交任务
Long aLong = submit.get();
//System.out.println(aLong);
long end = System.currentTimeMillis();
System.out.println("sum="+aLong+" 时间:"+(end-star));
}
/**
* 使用Stream 并行流
*/
public static void test3(){
long star = System.currentTimeMillis();
//Stream并行流()
long sum = LongStream.range(0L, 10_0000_0001L).parallel().reduce(0, Long::sum); //parallel 并行
//System.out.println(sum);
long end = System.currentTimeMillis();
System.out.println("sum="+sum+" 时间:"+(end-star));
}
}
.parallel().reduce(0, Long::sum)使用一个并行流去计算整个计算,提高效率。
reduce方法的优点:
15、异步回调
Future 设计的初衷:对将来的某个事件结果进行建模!
其实就是前端 --> 发送ajax异步请求给后端
但是我们平时都使用CompletableFuture
(1)没有返回值的runAsync异步回调
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
/**
* 异步调用 :CompletableFuture
* 异步执行
* 成功回调
* 失败回调
* */
public class Demo01 {
public static void main(String[] args) throws ExecutionException, InterruptedException
{
// 发起 一个 请求
System.out.println(System.currentTimeMillis());
System.out.println("11---------------------");
CompletableFuture<Void> future = CompletableFuture.runAsync(()->{
//static 直接调用
//发起一个异步回调任务 去异步执行
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"333.....");
});
System.out.println(System.currentTimeMillis());
System.out.println("222------------------------------");
//输出执行结果
System.out.println(future.get()+"444"); //异步回调获取返回值,获取执行结果,这里会阻塞
}
}
(2)有返回值的异步回调supplyAsync
//有返回值的异步回调
// ajax 成功和失败的回调 失败返回的是错误信息
CompletableFuture<Integer> completableFuture=CompletableFuture.supplyAsync(()->{
System.out.println(Thread.currentThread().getName());
try {
TimeUnit.SECONDS.sleep(2);
int i=1/0;
} 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 的理解
Volatile 是 Java 虚拟机提供 轻量级的同步机制
1、保证可见性
2、不保证原子性
3、禁止指令重排
什么是JMM?
JMM:Java内存模型,不存在的东西,概念!约定!
关于JMM的一些同步的约定:
1、线程解锁前,必须把共享变量立刻刷回主存;
2、线程加锁前,必须读取主存中的最新值到工作内存中;
3、加锁和解锁是同一把锁;
线程中分为 工作内存、主内存
8种操作:
-
Read(读取):作用于主内存变量,它把一个变量的值从主内存传输到线程的工作内存中,以便随后的load动作使用;
-
load(载入):作用于工作内存的变量,它把read操作从主存中变量放入工作内存中;
-
Use(使用):作用于工作内存中的变量,它把工作内存中的变量传输给执行引擎,每当虚拟机遇到一个需要使用到变量的值,就会使用到这个指令;
-
assign(赋值):作用于工作内存中的变量,它把一个从执行引擎中接受到的值放入工作内存的变量副本中;
-
store(存储):作用于主内存中的变量,它把一个从工作内存中一个变量的值传送到主内存中,以便后续的write使用;
-
write(写入):作用于主内存中的变量,它把store操作从工作内存中得到的变量的值放入主内存的变量中;
-
lock(锁定):作用于主内存的变量,把一个变量标识为线程独占状态;
-
unlock(解锁):作用于主内存的变量,它把一个处于锁定状态的变量释放出来,释放后的变量才可以被其他线程锁定;
JMM对这8种操作给了相应的规定:
-
不允许read和load、store和write操作之一单独出现。即使用了read必须load,使用了store必须write
-
不允许线程丢弃他最近的assign操作,即工作变量的数据改变了之后,必须告知主存
-
不允许一个线程将没有assign的数据从工作内存同步回主内存
-
一个新的变量必须在主内存中诞生,不允许工作内存直接使用一个未被初始化的变量。就是对变量实施use、store操作之前,必须经过assign和load操作
-
一个变量同一时间只有一个线程能对其进行lock。多次lock后,必须执行相同次数的unlock才能解锁
-
如果对一个变量进行lock操作,会清空所有工作内存中此变量的值,在执行引擎使用这个变量前,必须重新load或assign操作初始化变量的值
-
如果一个变量没有被lock,就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量
-
对一个变量进行unlock操作之前,必须把此变量同步回主内存
遇到问题:程序不知道主存中的值已经被修改过了!;
解决办法!
import java.util.concurrent.TimeUnit;
public class JMMDemo01 {
// 如果不加volatile 程序会死循环
// 加了volatile是可以保证可见性的
private volatile static Integer number = 0; //加上volatile 就可以及时通知到子线程,告诉其他线程已经修改了值
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);
}
}
17、Volatile
1、保证可见性
public class JMMDemo01 {
// 如果不加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();
}
//子线程2
new Thread(()->{
while (number==0){
}
}).start();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
number=1;
System.out.println(number);
}
}
2、不保证原子性
原子性:不可分割;
线程A在执行任务的时候,不能被打扰的,也不能被分割的,要么同时成功,要么同时失败。
import java.util.concurrent.TimeUnit;
/**
* 不保证原子性
* number <=2w
*
*/
public class VDemo02 {
private static volatile int number = 0;
public synchronized static void add(){
number++;
//++ 不是一个原子性操作,是两个~三个操作
//
// 可以给方法加上synchronized,或者另外使用lock 来保证原子性
}
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();
}
//System.out.println(number);
while (Thread.activeCount()>2){
//线程数量大于二
//main gc
Thread.yield(); //线程礼让 保证20个线程都执行完了
}
System.out.println(Thread.currentThread().getName()+",num="+number); //number总是没有2w
}
}
如果不加lock和synchronized ,怎么样保证原子性?
找到class文件路径 执行javap -c VDemo02.class
进行反编译查看字节码文件
解决方法:使用JUC下的原子包下的class;
代码如下:
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
/**
* 不保证原子性
* number <=2w
*
*/
public class VDemo02 {
private static volatile AtomicInteger number = new AtomicInteger();
public synchronized static void add(){
number.getAndIncrement(); //AtomicInteger +1 方法 ,原理CAS
}
public static void main(String[] args) {
for (int i = 1; i <= 20; i++) {
new Thread(()->{
for (int j = 1; j <= 1000 ; j++) {
add();
}
}).start();
}
while (Thread.activeCount()>2){
Thread.yield();
}
System.out.println(Thread.currentThread().getName()+",num="+number); //number总是没有2w
}
}
这些类的底层都直接和操作系统挂钩!是在内存中修改值。
Unsafe类是一个很特殊的存在;
什么是指令重排?
我们写的程序,计算机并不是按照我们自己写的那样去执行的
源代码–->编译器优化代码重排–->指令并行也可能会重排–->内存系统也会重排–->执行
处理器在进行指令重排的时候,会考虑数据之间的依赖性!
int x=1; //1
int y=2; //2
x=x+5; //3
y=x*x; //4
//我们期望的执行顺序是 1_2_3_4 可能执行的顺序会变成2134 1324
//可不可能是 4123? 不可能的
可能造成的影响结果:前提:a b x y这四个值 默认都是0
正常的结果: x = 0; y =0; 但是可能由于指令重排
可能在线程A中会出现,先执行b=1,然后再执行x=a;
在B线程中可能会出现,先执行a=2,然后执行y=b;
那么就有可能因为指令重排导致结果如下:x=2; y=1.
volatile可以避免指令重排:
volatile中会加一道内存的屏障,这个内存屏障可以保证在这个屏障中的指令顺序。
内存屏障:CPU指令。作用:
1、保证特定的操作的执行顺序;
2、可以保证某些变量的内存可见性(利用这些特性,就可以保证volatile实现的可见性)
总结
- volatile可以保证可见性;
- 不能保证原子性
- 由于内存屏障,可以保证避免指令重排的现象产生
面试官:那么你知道在哪里用这个内存屏障用得最多呢?单例模式
18、玩转单例模式(重点)
饿汉式、DCL懒汉式
饿汉式
/**
* 饿汉式单例 自动加载
*/
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;
import java.lang.reflect.InvocationTargetException;
//懒汉式单例模式 用的时候采取加载
public class LazyMan {
private static boolean key = false;
private LazyMan(){
synchronized (LazyMan.class){
if (key==false){
key=true;
}
else{
throw new RuntimeException("不要试图使用反射破坏异常");
}
}
System.out.println(Thread.currentThread().getName()+" ok");
}
private volatile static LazyMan lazyMan;
//双重检测锁模式 简称DCL懒汉式
public static LazyMan getInstance(){
//多线程下需要加锁
if(lazyMan==null){
synchronized (LazyMan.class){
if(lazyMan==null){
//如果为空 才去创建称为懒汉式
lazyMan=new LazyMan(); //不是一个原子性操作
/** new LzyMan()
* 1、分配内存空间
* 2、执行构造方法,初始化对象
* 3、把这个对象指向这个空间
*
* 就有可能出现指令重排问题
* 比如执行的顺序是1 3 2 等
* 我们就可以添加volatile保证指令重排问题
*/
}
}
}
return lazyMan;
}
//单线程下 是ok的
//但是如果是并发的
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
// for (int i = 0; i < 10; i++) {
// new Thread(()->{
// getInstance();
// }).start();
// }
//
//Java中有反射 可以搞破坏
//LazyMan instance = LazyMan.getInstance();
//Field key = LazyMan.class.getDeclaredField("key");
//key.setAccessible(true);
Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null); //获得空参构造器
declaredConstructor.setAccessible(true); //无视了私有的构造器 破坏单例
//通过反射来创建的对象
LazyMan lazyMan1 = declaredConstructor.newInstance();
//key.set(lazyMan1,false);
LazyMan instance2 = declaredConstructor.newInstance();
//System.out.println(instance);
System.out.println(instance2);
System.out.println(lazyMan1);
}
}
静态内部类
//静态内部类
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;
import java.lang.reflect.InvocationTargetException;
//enum 是什么? enum本身就是一个Class 类
public enum EnumSingle {
INSTANCE; //这个对象 默认就是单例的
public EnumSingle getInstance(){
return INSTANCE;
}
}
class Test{
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
EnumSingle instance1 = EnumSingle.INSTANCE; //获得对象
Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);//这里的参数 我们根据反编译将class再变为java,然后可以看到一个有参构造
declaredConstructor.setAccessible(true); //利用反射去破坏枚举
//java.lang.NoSuchMethodException: com.ogj.single.EnumSingle.<init>()
EnumSingle instance2 = declaredConstructor.newInstance(); //利用枚举获得对象
System.out.println(instance1);
System.out.println(instance2);
}
}
使用枚举,我们就可以防止反射破坏了。
枚举类型使用JAD最终反编译后源码:
如果我们看idea 的文件:会发现idea骗了我们,它告诉我们是有 无参构造的,我们使用jad进行反编译。
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/ogj/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
});
}
}
19、深入理解CAS
什么是CAS?
大厂必须深入研究底层!!!!修内功!操作系统、计算机网络原理、组成原理、数据结构
import java.util.concurrent.atomic.AtomicInteger;
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());
}
}
进入我们的getAndIncrement() 查看原理
查看Unsafe源码
Unsafe类
总结:
CAS:比较当前工作内存中的值 和 主内存中的值,如果这个值是期望的,那么则执行操作!如果不是就一直循环,使用的是自旋锁。
缺点:
- 循环会耗时;
- 一次性只能保证一个共享变量的原子性;
- 它会存在ABA问题
CAS:ABA问题?(狸猫换太子)
线程1:期望值是1,要变成2;
线程2:两个操作:
- 1、期望值是1,变成3
- 2、期望是3,变成1
所以对于线程1来说,它拿到的A的值还是1,所以就出现了ABA问题,骗过了线程1;
import java.util.concurrent.atomic.AtomicInteger;
public class casDemo {
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, 2022)); //其实已经有线程修改过我们的值了
System.out.println(atomicInteger.get());
}
}
那么我们要怎么才能知道有线程修改过值? 乐观锁 !
原子引用来解决!!
20、原子引用
解决ABA问题,对应的思想:就是使用了乐观锁~
带版本号的 原子操作!
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicStampedReference;
public class casDemo {
public static void main(String[] args) {
AtomicStampedReference<Integer> atomicInteger = new AtomicStampedReference<>(20, 1); //初始值,时间戳(版本号)
//我们要让b线程知道a线程的操作
new Thread(()->{
int stamp = atomicInteger.getStamp(); //获得版本号
System.out.println("a1->"+stamp);
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(atomicInteger.compareAndSet(20, 21, atomicInteger.getStamp(), atomicInteger.getStamp() + 1));
System.out.println("a2->"+atomicInteger.getStamp());
System.out.println(atomicInteger.compareAndSet(21, 20, atomicInteger.getStamp(), atomicInteger.getStamp() + 1));
System.out.println("a3->"+atomicInteger.getStamp());
},"a").start();
new Thread(()->{
int stamp = atomicInteger.getStamp(); //获得版本号
System.out.println("b1->"+stamp);
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(atomicInteger.compareAndSet(20, 66, atomicInteger.getStamp(), atomicInteger.getStamp() + 1));
System.out.println("b2->"+atomicInteger.getStamp());
},"b").start();
}
Integer 使用了对象缓存机制,默认范围是-128~127,查过这个值就会重新分配内存空间,推荐使用静态工厂方法valueOf 获取对象实例,而不是new,因为valueOf使用缓存,而new一定会创建新的对象分配新的内存空间。
所以如果遇到,使用大于128的时候,使用原子引用的时候,如果超过了这个值,那么就不会进行版本上升!
那么如果我们使用小于128的时候:
正常业务操作中,我们一般引用使用的是一个个对象,而不是Integer,一般情况不会遇到这种情况。
21、各种锁的理解
1、公平锁、非公平锁
公平锁:非常公平;不能插队的,必须先来后到;
/**
* Creates an instance of {@code ReentrantLock} with the
* given fairness policy.
*
* @param fair {@code true} if this lock should use a fair ordering policy
*/
public ReentrantLock(boolean fair) {
//为true 就是公平锁
sync = fair ? new FairSync() : new NonfairSync();
}
非公平锁:非常不公平,允许插队的,可以改变顺序(默认都是非公平!)。
/**
* Creates an instance of {@code ReentrantLock}.
* This is equivalent to using {@code ReentrantLock(false)}.
*/
public ReentrantLock() {
sync = new NonfairSync();
}
2、可重入锁
可重入锁(递归锁)
Synchronized锁
import java.util.concurrent.TimeUnit;
//Synchronized
public class Demo01 {
public static void main(String[] args) {
Phone phone = new Phone();
Phone phone1 = new Phone();
new Thread(()->{
phone.sms();
},"A").start();
new Thread(()->{
phone1.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");
}
}
A=> sms
A=> call
B=> sms
B=> 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()和unlock() 必须配对!
//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();
}
}
}
- lock锁必须配对,相当于lock和 unlock 必须数量相同;
- 在外面加的锁,也可以在里面解锁;在里面加的锁,在外面也可以解锁;
3、自旋锁
spinlock
自己设计自旋锁:
import java.util.concurrent.atomic.AtomicReference;
/**
* 自旋锁
*/
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);
}
}
测试
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
public class TestSpinLock {
public static void main(String[] args) throws InterruptedException {
// ReentrantLock reentrantLock = new ReentrantLock();
// reentrantLock.lock();
// reentrantLock.unlock();
// 我们现在用自己的锁 原理使用的是自旋锁
// SpinlockDemo spinlockDemo=new SpinlockDemo();
// spinlockDemo.myLock();
// spinlockDemo.myUnLock();
//使用CAS实现自旋锁
SpinlockDemo spinlockDemo=new SpinlockDemo();
new Thread(()->{
spinlockDemo.myLock();
try {
TimeUnit.SECONDS.sleep(3);
} catch (Exception e) {
e.printStackTrace();
} finally {
spinlockDemo.myUnLock();
}
},"t1").start();
TimeUnit.SECONDS.sleep(1);
new Thread(()->{
spinlockDemo.myLock();
try {
TimeUnit.SECONDS.sleep(3);
} catch (Exception e) {
e.printStackTrace();
} finally {
spinlockDemo.myUnLock();
}
},"t2").start();
}
}
t2进程必须等待t1进程Unlock后,才能Unlock,在这之前进行自旋等待。。。。
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()+" 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);
}
}
}
}
解决问题
1、使用jps定位进程号,jdk的bin目录下: 有一个jps
命令:jps -l
在死锁的条件下,在IDEA终端执行
2、使用jstack
+ 进程号 找到死锁信息
一般情况信息在最后:
面试,工作中!排查问题!
1、日志
2、堆栈信息