今天学的赶紧记录，之前没赶的进度之后搞。。
目录
多线程
1.cpu基础知识
2.多线程效率问题与底层原理
3.多线程创建方式
4.线程安全性问题
5.synchronized基本用法
6.如何保证线程同步问题
多线程
1.cpu基础知识
cpu:中央处理器→1.运算器 作用运算
2.控制器 负责发出cpu每条指令所需信息
3.寄存器 保存运算或指令的一些临时文件
进程：1.cpu从硬盘中读取一段程序到内存中，该执行程序的实例叫进程。
2.一个程序如果被cpu多次读取到内存中，则变成多个独立进程。
线程：线程是程序执行的最小单位，在进程中可以有多个不同的线程同时执行。(同一个过程中，更好并行处理)
线程运行在cpu之上
总结：进程是资源分配最小单位，线程是程序执行最小单位。
2.多线程效率问题与底层原理
1.为什么使用多线程？
采用多线程形式执行代码，目的就是为了提高程序效率。
2.串行/并行区别？
串行 单线程执行，代码效率低代码从上到下。
并行 多线程并行一起执行，效率高。
3.使用多线程一定效率高？
不一定，cpu调度的算法，先把前一个任务的cpu上下文(也就是cpu寄存器和程序计数器：从汇编语言底层
角度，不是java源代码角度，Java源代码一句可能汇编会有四句)保存起来，然后加载新任务的上下文到这些
寄存器和程序计数器，最后在跳转到程序计数器所指的新位置，运行新任务。
4.什么是上下文？
所谓多线程，在线程数远大于cpu内核数是，所有线程被cpu调度时间片所调度，在短时间内多次在运行状
态和就绪状态之间切换。(如果生产环境中开启几百个或几千个线程，而我们服务器内核数一般8、16、32 ，
这么多线程都会在cpu上做上下文切换，导致效率低下)
5.一般会设置线程池：8内核的cpu可以限定最多八个线程，减少cpu做上下文切换。
6.多线程同步/异步的区别？
同步：代码从上到下运行
异步：单独分支运行，相互之间没有影响
3.多线程创建方式
①继承Thread
new Thread(thread01).start();
②实现Runnable类
Thread abc = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("abc");
}
});
abc.start();
③使用匿名内部类
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("abc");
}
}).start();
④使用lamda表达式
new Thread(() -> System.out.println("abc")).start();
⑤使用callable和Future创建
//先创建一个ThreadCallable类
ThreadCallable threadCallable = new ThreadCallable();
FutureTask integerFutureTask = new FutureTask(threadCallable);
Thread thread = new Thread(integerFutureTask);
thread.start();
⑥使用线程池例如Executor
ExecutorService executorService = Executor.newCachedThreadpod();
executorService.execute(() -> System.out.println("") );
⑦spring @Async
4.线程安全性问题
1.线程安全问题定义
当多个线程共享一个全局变量(放在堆内存中)，在做写操作时，可能会受到其他线程干扰，发生线程安全性
问题。
2.如何解决线程安全性问题？/如何实现线程同步？
在同一JVM中，多个线程需要竞争锁资源，最终只有一个线程能够获取锁，多个线程同时抢同一把锁，谁能获取到锁，谁就可以被执行，如果一直没有获取锁成功，中间就要经历锁的升级，如果一直没有获得到锁，该线程就一直会阻塞等待。(核心思想：同JVM中当多个线程共享同一个全局变量时，将可能会发生线程安全性的代码上锁，保证只有拿到锁的线程才可以执行，没有拿到锁的线程不可以执行，需要阻止。)
3.JUC并发编程：重入锁、悲观锁、乐观锁、公平锁、非公平锁(synchronized锁)
4.代码加锁的缺点：可能会影响到程序的执行效率。
5.synchronized基本用法
1.修饰代码块
synchronized(对象锁){
需要保证线程安全的代码。
}
2.修饰实例方法(this锁)
3.修饰静态方法(类名.class锁)
tips:1.多线程情况下，需要的是同一个对象锁。
2.注意synchronized锁的死锁问题，锁嵌套会引发死锁问题。
6.如何保证线程同步问题
如何保证线程同步问题(如何1保证线程安全性问题)？(具体操作)
1.使用synchronized锁，jdk1.6锁的升级过程(偏量锁→轻量级锁→重量级锁)
2.使用Lock锁，需要自己完成锁的升级过程，底层基于AQS+CAS实现。
3.使用ThreadLocal,需要注意内存泄漏问题
4.原子类CAS 非阻塞式
cpu:中央处理器→1.运算器 作用运算
2.控制器 负责发出cpu每条指令所需信息
3.寄存器 保存运算或指令的一些临时文件
进程：1.cpu从硬盘中读取一段程序到内存中，该执行程序的实例叫进程。
2.一个程序如果被cpu多次读取到内存中，则变成多个独立进程。
线程：线程是程序执行的最小单位，在进程中可以有多个不同的线程同时执行。(同一个过程中，更好并行处理)
线程运行在cpu之上
总结：进程是资源分配最小单位，线程是程序执行最小单位。
2.多线程效率问题与底层原理
1.为什么使用多线程？
采用多线程形式执行代码，目的就是为了提高程序效率。
2.串行/并行区别？
串行 单线程执行，代码效率低代码从上到下。
并行 多线程并行一起执行，效率高。
3.使用多线程一定效率高？
不一定，cpu调度的算法，先把前一个任务的cpu上下文(也就是cpu寄存器和程序计数器：从汇编语言底层
角度，不是java源代码角度，Java源代码一句可能汇编会有四句)保存起来，然后加载新任务的上下文到这些
寄存器和程序计数器，最后在跳转到程序计数器所指的新位置，运行新任务。
4.什么是上下文？
所谓多线程，在线程数远大于cpu内核数是，所有线程被cpu调度时间片所调度，在短时间内多次在运行状
态和就绪状态之间切换。(如果生产环境中开启几百个或几千个线程，而我们服务器内核数一般8、16、32 ，
这么多线程都会在cpu上做上下文切换，导致效率低下)
5.一般会设置线程池：8内核的cpu可以限定最多八个线程，减少cpu做上下文切换。
6.多线程同步/异步的区别？
同步：代码从上到下运行
异步：单独分支运行，相互之间没有影响
3.多线程创建方式
①继承Thread
new Thread(thread01).start();
②实现Runnable类
Thread abc = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("abc");
}
});
abc.start();
③使用匿名内部类
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("abc");
}
}).start();
④使用lamda表达式
new Thread(() -> System.out.println("abc")).start();
⑤使用callable和Future创建
//先创建一个ThreadCallable类
ThreadCallable threadCallable = new ThreadCallable();
FutureTask integerFutureTask = new FutureTask(threadCallable);
Thread thread = new Thread(integerFutureTask);
thread.start();
⑥使用线程池例如Executor
ExecutorService executorService = Executor.newCachedThreadpod();
executorService.execute(() -> System.out.println("") );
⑦spring @Async
4.线程安全性问题
1.线程安全问题定义
当多个线程共享一个全局变量(放在堆内存中)，在做写操作时，可能会受到其他线程干扰，发生线程安全性
问题。
2.如何解决线程安全性问题？/如何实现线程同步？
在同一JVM中，多个线程需要竞争锁资源，最终只有一个线程能够获取锁，多个线程同时抢同一把锁，谁能获取到锁，谁就可以被执行，如果一直没有获取锁成功，中间就要经历锁的升级，如果一直没有获得到锁，该线程就一直会阻塞等待。(核心思想：同JVM中当多个线程共享同一个全局变量时，将可能会发生线程安全性的代码上锁，保证只有拿到锁的线程才可以执行，没有拿到锁的线程不可以执行，需要阻止。)
3.JUC并发编程：重入锁、悲观锁、乐观锁、公平锁、非公平锁(synchronized锁)
4.代码加锁的缺点：可能会影响到程序的执行效率。
5.synchronized基本用法
1.修饰代码块
synchronized(对象锁){
需要保证线程安全的代码。
}
2.修饰实例方法(this锁)
3.修饰静态方法(类名.class锁)
tips:1.多线程情况下，需要的是同一个对象锁。
2.注意synchronized锁的死锁问题，锁嵌套会引发死锁问题。
6.如何保证线程同步问题
如何保证线程同步问题(如何1保证线程安全性问题)？(具体操作)
1.使用synchronized锁，jdk1.6锁的升级过程(偏量锁→轻量级锁→重量级锁)
2.使用Lock锁，需要自己完成锁的升级过程，底层基于AQS+CAS实现。
3.使用ThreadLocal,需要注意内存泄漏问题
4.原子类CAS 非阻塞式
①继承Thread
new Thread(thread01).start();
②实现Runnable类
Thread abc = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("abc");
}
});
abc.start();
③使用匿名内部类
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("abc");
}
}).start();
④使用lamda表达式
new Thread(() -> System.out.println("abc")).start();
⑤使用callable和Future创建
//先创建一个ThreadCallable类
ThreadCallable threadCallable = new ThreadCallable();
FutureTask integerFutureTask = new FutureTask(threadCallable);
Thread thread = new Thread(integerFutureTask);
thread.start();
⑥使用线程池例如Executor
ExecutorService executorService = Executor.newCachedThreadpod();
executorService.execute(() -> System.out.println("") );
⑦spring @Async
4.线程安全性问题
1.线程安全问题定义
当多个线程共享一个全局变量(放在堆内存中)，在做写操作时，可能会受到其他线程干扰，发生线程安全性
问题。
2.如何解决线程安全性问题？/如何实现线程同步？
在同一JVM中，多个线程需要竞争锁资源，最终只有一个线程能够获取锁，多个线程同时抢同一把锁，谁能获取到锁，谁就可以被执行，如果一直没有获取锁成功，中间就要经历锁的升级，如果一直没有获得到锁，该线程就一直会阻塞等待。(核心思想：同JVM中当多个线程共享同一个全局变量时，将可能会发生线程安全性的代码上锁，保证只有拿到锁的线程才可以执行，没有拿到锁的线程不可以执行，需要阻止。)
3.JUC并发编程：重入锁、悲观锁、乐观锁、公平锁、非公平锁(synchronized锁)
4.代码加锁的缺点：可能会影响到程序的执行效率。
5.synchronized基本用法
1.修饰代码块
synchronized(对象锁){
需要保证线程安全的代码。
}
2.修饰实例方法(this锁)
3.修饰静态方法(类名.class锁)
tips:1.多线程情况下，需要的是同一个对象锁。
2.注意synchronized锁的死锁问题，锁嵌套会引发死锁问题。
6.如何保证线程同步问题
如何保证线程同步问题(如何1保证线程安全性问题)？(具体操作)
1.使用synchronized锁，jdk1.6锁的升级过程(偏量锁→轻量级锁→重量级锁)
2.使用Lock锁，需要自己完成锁的升级过程，底层基于AQS+CAS实现。
3.使用ThreadLocal,需要注意内存泄漏问题
4.原子类CAS 非阻塞式
1.修饰代码块
synchronized(对象锁){
需要保证线程安全的代码。
}
2.修饰实例方法(this锁)
3.修饰静态方法(类名.class锁)
tips:1.多线程情况下，需要的是同一个对象锁。
2.注意synchronized锁的死锁问题，锁嵌套会引发死锁问题。
