什么是JUC？
java.util.current
Runnable：没有返回值，效率相比Callable相对较低
2、线程和进程
进程：一个程序，QQ.exe Music.exe 程序的集合
一个进程往往可以包含多个线程，至少包含一个！
java默认有几线程？ 2个 main、GC线程
线程：开了一个进程Typor,写字，自动保存（线程负责的）
**java真的能开启线程吗？**开不了（java是没有权限的）
并发、并行
并发（多线程操作同一个资源）
比如CPU一核，模拟出来多条线程，天下武功，为快不破，快速交替（产生一个假象）
并行（多个人一起行走）
比如CPU多核，多个线程可以同时执行
并发编程的本质，充分利用CPU的资源（企业为了提高效率）
线程有几个状态（查看源码得知）
线程新生（NEW）
线程运行（RUNABLE）
线程阻塞（BLOCKED）
线程等待（WAITING）死死的等
超时等待（TIME_WAITING）
终止（TERMINATED）
wait和sleep区别
1、首先他们来自不同的类
wait—》Object
sleep–》Thread
企业中，休眠，会用（java.util.current.TimeUnit这个类）
2、关于锁的释放
wait会释放锁，而sleep会持有锁（抱着锁睡觉，不会释放）
3、使用的范围不同
wait必须在同步代码块中
sleep可以在任何地方睡
4、是否需要捕获异常
wait不需要捕获异常
sleep必须要捕获异常
3、Lock锁（重点）
传统Synchronized（本质：队列，锁）
真正的多线程开发，公司中的开发，降低耦合性，线程就是一个单独的资源类，没有任何的附属操作（属性、方法）
Lock接口
RentrantLock
公平锁：十分公平：可以先来后到
非公平锁：十分不公平：可以插队（默认）
Lock锁和Synchronized区别
1、Synchronized 内置java关键字，Lock是一个java类
2、Synchronized 无法判断获取锁的状态，Lock可以判断是否获取到了锁
3、Synchronized 会自动释放锁，而Lock锁必须要手动释放锁。如果不释放锁，会产生死锁
4、Synchronized 线程一（获得锁、阻塞）、线程二（等待，傻傻的等）；Lock锁就不一定会等待下去（lock.tryLock() 尝试获取锁）
5、Synchronized可重入锁，不可以中断的，非公平；Lock，可重入锁，可以判断锁，非公平（可以自己设置）；
6、Synchronized 适合锁少量的代码同步问题；Lock适合锁大量的同步代码块
4、生产者和消费者问题
面试的算法：单例模式、8大排序算法、生产者和消费者、死锁
Synchronized版：
问题存在，A、B、C、D四个线程，还安全吗？存在虚假唤醒if判断改为while判断
JUC版的生产者和消费者问题
代码实现
Condition任何一个新的技术，绝对不是仅仅为了覆盖原来的技术，优势和补充！
Condition精准的通知和唤醒线程（ABC线程顺序执行）
5、锁是什么？如何判断锁的是谁？8锁现象
如何判断锁的是谁? 对象、Class
深刻理解锁
Synchronized锁的对象是方法的调用者！
小结：
new出来的 this 具体的一个手机
static Class 唯一的一个模板
6、集合类不安全（并发下不安全）
List不安全
package com.itheima.kiki.demo01;
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
/**
* @author zs
* @version 1.0
* @create 2020/6/4 13:32
*/
//java.util.ConcurrentModificationException 并发修改异常
public class ListTest {
public static void main(String[] args) {
// List<String> list = Arrays.asList("1", "2", "3");
// list.forEach(System.out::println);
//并发下ArrayList是不安全的
/**
* 解决方案：
* 1、List<String> list = new Vector<>(); Vector jdk1.0就出现了
* 2、List<String> list = Collections.synchronizedList(new ArrayList<>());
* 3、List<String> list = new CopyOnWriteArrayList<>();// JUC解决方案
*/
//List<String> list = new ArrayList<>(); //ArrayList jdk1.2
//List<String> list = new Vector<>();
//让ArrayList变得安全
//List<String> list = Collections.synchronizedList(new ArrayList<>());
//CopyOnWrite 写入时复制，简称COW 计算机程序设计领域的 一种优化策略
//多线程调用的时候，List 读取的时候，是固定的，但是写入的时候可能存在覆盖操作
//在写入的时候避免覆盖造成数据问题
//读写分离 MyCat
//CopyOnWriteArrayList比 Vector牛逼在哪个地方？
//Vetor 底层用了Synchronized关键字，只要有Synchronized的地方效率就会低
//而CopyOnWriteArrayList 底层使用的Lock锁
List<String> list = new CopyOnWriteArrayList<>();// JUC解决方案
for (int i = 1; i <=10 ; i++) {
new Thread(()->{
list.add(UUID.randomUUID().toString().substring(0,5));
System.out.println(list);
},String.valueOf(i)).start();
}
}
}
学习方法：
1、先会用
2、货比三家，寻找其他解决方案
3、分析源码
Set不安全
package com.itheima.kiki.demo01;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArraySet;
/**
* @author zs
* @version 1.0
* @create 2020/6/4 14:20
*/
/**
* 同理可证 java.util.ConcurrentModificationException 并发修改异常
* 解决方案：
* 1：Set<String> set = Collections.synchronizedSet(new HashSet<>());
* 2：Set<String> set = new CopyOnWriteArraySet<>();
*/
public class SetTest {
public static void main(String[] args) {
//HashSet<String> set = new HashSet<>();
//Set<String> set = Collections.synchronizedSet(new HashSet<>());
Set<String> set = new CopyOnWriteArraySet<>();
for (int i = 1; i <= 10; i++) {
new Thread(()->{
set.add(UUID.randomUUID().toString().substring(0,5));
System.out.println(set);
},String.valueOf(i)).start();
}
}
}
HashSet的底层是什么？
public HashSet() {
map = new HashMap<>();
}
//add set的本质就是map key是无法重复的并且是无序的
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
private static final Object PRESENT = new Object(); //不变的值
Map也是不安全的
回顾map的基本操作
package com.itheima.kiki.demo01;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
/**
* @author zs
* @version 1.0
* @create 2020/6/4 14:38
*/
/**java.util.ConcurrentModificationException 并发修改异常
* 解决方案：
* 1、Map<String, String> map = new ConcurrentHashMap<>();
*/
public class MapTest {
public static void main(String[] args) {
//map 是这样用的吗？不是，工作中不用这个
// 默认等价于什么？ new HashMap<>(0.75,16); //加载因子、初始化容量
//Map<String, String> map = new HashMap<>();
Map<String, String> map = new ConcurrentHashMap<>();
for (int i = 1; i <= 30; i++) {
new Thread(()->{
map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
System.out.println(map);
},String.valueOf(i)).start();
}
}
}
7、Callable
1、可以有返回值
2、可以抛出异常
3、方法不同 run()/ call()
代码测试
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
/**
* @author zs
* @version 1.0
* @create 2020/6/4 15:00
*/
/**
* 1、探究原理
* 2、觉得自己会用
*/
public class CallableTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//new Thread(new MyThread()).start();
//new Thread(new Runnable()).start();
//new Thread(new FutureTask<V>()).start();
//new Thread(new FutureTask<V>(Callable)).start();
new Thread().start();//怎么启动callable
MyThread thread = new MyThread();
//适配类
FutureTask futureTask = new FutureTask(thread);
new Thread(futureTask,"A").start();
new Thread(futureTask,"B").start(); //结果会被缓存，效率高
String o = (String) futureTask.get();//获取Callable的返回结果，这个get方法可能会产生阻塞！把它放在最后，或者使用异步通信来处理
System.out.println(o);
}
}
//class MyThread implements Runnable{
// @Override
// public void run() {
// }
//}
class MyThread implements Callable<String>{
@Override
public String call() {
System.out.println("call()");
//耗时的操作
return "123456";
}
}
细节：
1、有缓存
2、结果可能会要等待，会阻塞！
（内容接第二部分https://blog.csdn.net/qq_38616503/article/details/106559170）