一. 线程安全问题
线程安全问题：多线程同时对同一个全局变量做写的操作，可能会受到其他线程的干扰，就会发生线程安全性问题，涉及到java的内存结构，全局共享变量存储在堆中，堆内存是共享的，下面模拟两个线程冲突概率较大的情况，因为cpu是多核的所以当线程从阻塞状态到运行状态的时候两个线程会同时对全局变量进行操作那么发生冲突的概率就会大很多，可以发现输出结果的差异是比较大的：（多线程中一个核心的概念是同时执行）
package thread;
public class ThreadCount implements Runnable{
private int count = 100;
@Override
public void run() {
while (true){
if (count > 1){
try {
// 运行状态----休眠状态----cup的执行权让给其他的线程
Thread.sleep(3000);
// 休眠状态
}catch (Exception e){
}
count--;
System.out.println(Thread.currentThread().getName() + " " + count);
}
}
}
public static void main(String[] args) {
ThreadCount threadCount = new ThreadCount();
new Thread(threadCount).start();
new Thread(threadCount).start();
}
}多线程如何解决线程安全问题/ 多线程如何实现同步呢？这两个问题属于同一个问题，核心思想：锁、分布式锁
在同一个 jvm 中，多个线程需要竞争锁的资源，最终只能够有一个线程能够获取到锁，多个线程同时抢同一把锁，谁（线程）能够获取到锁，谁就可以执行到该代码，如果没有获取锁成功 中间需要经历锁的升级过程，如果一致没有获取到锁则会一直阻塞等待。如果线程 A 获取锁成功 但是线程 A 一直不释放锁，线程 B 一直获取不到锁，则会一直阻塞等待。代码从那一块需要上锁？ -----可能会发生线程安全性问题的代码需要上锁。juc 并发编程：锁，重入锁，悲观锁，乐观锁，公平锁，非公平锁。对一块代码加锁缺点：可能会影响到程序的执行效率，获取锁与释放锁全部都是有底层虚拟机实现好了。如果是同一把锁在多线程的情况下最终只能够给一个线程使用。如果有线程持有了该锁意味着其他的线程不能够在继续获取锁。如果是同一把锁在多线程的情况下最终只能够给一个线程使用。
加锁之后那么结果就是正确的：
package thread;
public class ThreadCount implements Runnable{
private int count = 100;
@Override
public void run() {
while (true){
if (count > 1){
// 加锁
synchronized (this){
count--;
System.out.println(Thread.currentThread().getName() + " " + count);
}
}
}
}
public static void main(String[] args) {
ThreadCount threadCount = new ThreadCount();
new Thread(threadCount).start();
new Thread(threadCount).start();
}
}二. synchronized 锁的基本用法
线程如何实现同步？本质上问的是线程如何保证线程安全性的问题，主要包括以下几个方面：
1.?使用 synchronized 锁，从jdk1.6开始，锁的升级过程，偏向锁--->轻量级锁--->重量级锁；
2. 使用Lock锁(JUC)，需要自己实现锁的升级过程，底层是基于aps和cas实现；
3. 使用ThreadLocal，需要注意内存泄漏的问题
4. 原子类CAS非阻塞式
Spring MVC Controller 默认是单例的(spring默认bean对象是单例的)，所以需要注意线程安全问题，单例的原因有二：
1. 为了性能；
2. 不需要多例；
例如在控制器中有一个count()方法，当多个请求访问的时候，多个请求线程访问当前方法的过程中那么就会发生线程安全问题，这个时候就需要加锁保证线程安全问题，所有请求过来都会访问到count()方法，当多个请求进行访问的时候那么多个线程就会造成锁资源竞争的问题（在浏览器中多次刷新页面发送新的请求），由于spring mvc的Controller是单例的而且加上了this锁所以每个请求线程获取到锁之后那么其余的请求只能够等待，所以相当于是单线程：
package com.example.demo.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class LockController {
private int count = 0;
@RequestMapping("/count")
public synchronized String count() throws InterruptedException {
// 每个请求花费3s那么3个请求总共花费9s的时间(刷新三次), 可以通过打印count的输出判断是否是单例的
Thread.sleep(3000);
System.out.println(count++);
return "count";
}
}我们可以使用@Scope(value = "prototype")注解将当前的Bean对象修改为多例，这样每个请求过来就不会共享全局变量count，每个synchronized锁都是不同的this锁，所以不需要竞争锁资源：
import org.springframework.context.annotation.Scope;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@Scope(value = "prototype")
public class LockController {
private int count = 0;
@RequestMapping("/count")
public synchronized String count() throws InterruptedException {
// 每个请求花费3s那么3个请求总共花费9s的时间(刷新三次)
Thread.sleep(3000);
System.out.println(count++);
return "count";
}
}三. 多线程之间的通信--wait()和notify()方法
多线程之间的通信
wait()方法：释放锁资源, 同时当前线程会阻塞，例如下面的代码运行会报错，因为调用this.wait()的时候没有告诉锁对象，wait()和notify()方法需要结合synchronized对象锁使用，wait释放的是同步代码块中的对象锁，当前获取的是哪个对象锁那么就释放哪个对象锁，如果调用其他的锁会抛出异常：
package com.example.demo.controller;
public class Test01 {
public static void main(String[] args) throws InterruptedException {
new Test01().print();
}
public void print() throws InterruptedException {
// wait()方法: 释放锁资源, 同时当前线程会阻塞
this.wait();
}
}加上synchronized锁，当主线程进入到print()方法的时候获取到this锁执行到this.wait()的时候释放锁资源同时主线程也会阻塞:
public class Test01 {
public static void main(String[] args) throws InterruptedException {
new Test01().print();
}
public void print() throws InterruptedException {
synchronized (this){
System.out.println("<1>");
System.out.println(Thread.currentThread().getName());
// wait()方法: 释放锁资源, 同时当前线程会阻塞
this.wait();
System.out.println("<2>");
}
}
}并且需要注意的是wait()方法在调用的时候需要获取到锁的对象，也即锁的对象.wait()，因为当前是this锁所以需要使用this.wait()调用，当前是哪种锁那么使用谁来调用，例如下面的例子是string类型的lock锁那么使用lock.wait()调用：
public class Test01 {
private String lock = "lock";
public static void main(String[] args) throws InterruptedException {
new Test01().print();
}
public void print() throws InterruptedException {
// 当前是lock锁所以需要使用lock.wait()来调用
synchronized (lock){
System.out.println("<1>");
System.out.println(Thread.currentThread().getName());
lock.wait();
System.out.println("<2>");
}
}
}下面的代码在运行3s之后主线程唤醒子线程之后会报错，这是因为notify()方法需要放到同步代码块里面：
public class Test01 {
private String lock = "lock";
public static void main(String[] args) throws InterruptedException {
new Test01().print();
}
public void print() throws InterruptedException {
// 使用匿名函数创建和启动一个子线程
new Thread(() -> {
synchronized (lock){
System.out.println("<1>");
System.out.println(Thread.currentThread().getName() + " ====>");
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("<2>");
}
}).start();
// 主线程3s之后唤醒子线程
try {
Thread.sleep(3000);
lock.notify();
}catch (Exception e){
// 输出报错的信息
e.printStackTrace();
}
}
}将notify()方法放到同步代码块里面那么就不会报错了(wait()和notify()方法需要放到同步代码块中)：
public class Test01 {
private String lock = "lock";
public static void main(String[] args) throws InterruptedException {
new Test01().print();
}
public void print() throws InterruptedException {
// 使用匿名函数创建和启动一个子线程
new Thread(() -> {
synchronized (lock){
System.out.println("<1>");
System.out.println(Thread.currentThread().getName() + " ====>");
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("<2>");
}
}).start();
// 主线程3s之后唤醒子线程
try {
Thread.sleep(3000);
synchronized (lock){
lock.notify();
}
}catch (Exception e){
// 输出报错的信息
e.printStackTrace();
}
}
}注意主线程必须要休眠一段时间，因为main()方法调用print()函数的时候有可能在启动的子线程的时候，print()方法中的主线程已经执行完了，也即先执行了lock.notify()方法，此时再执行子线程中的方法那么就唤醒不了子线程了，所以需要调用Thread.sleep()方法暂停当前的主线程，把cpu片段让出给其他线程，减缓当前线程的执行，多次运行可能结果是不一样的：
public class Test01 {
private String lock = "lock";
public static void main(String[] args) throws InterruptedException {
new Test01().print();
}
public void print() throws InterruptedException {
// 使用匿名函数创建和启动一个子线程
new Thread(() -> {
synchronized (lock){
System.out.println("<1>");
System.out.println(Thread.currentThread().getName() + " ====>");
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("<2>");
}
}).start();
// 下面的try-catch代码块属于主线程
try {
System.out.println(Thread.currentThread().getName() + " ====>");
synchronized (lock){
System.out.println("唤醒子进程");
lock.notify();
System.out.println("唤醒子进程结束");
}
}catch (Exception e){
// 输出报错的信息
e.printStackTrace();
}
}
}输出结果可能为下面这两种情况，其实主线程和子线程是并行执行的，当先执行lock.notify()方法的时候子线程是无法被主线程唤醒的，当先执行子线程的时候那么执行到主线程中的lock.notify()方法之后那么就会被唤醒，唤醒之后输出"<2>"最终主线程结束，如果没有唤醒子线程那么子线程会一直阻塞无法退出：
1. 第一种输出结果:
main ====>
唤醒子进程
唤醒子进程结束
<1>
Thread-0 ====>
2. 第二种输出结果:
main ====>
<1>
Thread-0 ====>
唤醒子进程
唤醒子进程结束
<2>
...主进程以代码0退出wait()，notify()生产者与消费者模型：
下面的例子中当由于Res是全局变量，所以当输入线程和输出线程共享全局变量的时候就有可能发生线程安全问题，下面的代码输出结果就是错误的，解决线程安全问题的一个方法是对发生线程安全的代码块加上锁，其实也好理解，因为Res是全局共享变量所以当输入线程执行的时候将username = "hexin"，当切换到输出线程的时候那么输出当前全局res.username，然后可能又切换到输入线程那么将username = "xiaohong"，再执行sex = '女'，此时切换到输出输出线程那么输出sex = '女'，所以就出现了错误：
public class Thread02 {
// 共享对象
class Res{
public String username;
public char sex;
}
// 输入线程对应的类
class InputThread extends Thread{
private Res res;
public InputThread(Res res){
this.res = res;
}
// 重写run()方法
@Override
public void run() {
int count = 0;
while (true){
if (count == 0){
res.username = "hexin";
res.sex = '男';
}else{
res.username = "xiaohong";
res.sex = '女';
}
count = (count + 1) % 2;
}
}
}
// 输出线程对应的类
class OutputThread extends Thread{
@Override
public void run() {
while (true){
System.out.println(res.username + " " + res.sex);
}
}
private Res res;
public OutputThread(Res res){
this.res = res;
}
}
public static void main(String[] args) {
new Thread02().print();
}
public void print(){
// Res为全局共享变量
Res res = new Res();
InputThread inputThread = new InputThread(res);
OutputThread outputThread = new OutputThread(res);
// 启动输入线程和输出线程
inputThread.start();
outputThread.start();
}
}使用synchronized为代码块加上锁，因为Res是全局共享变量，所以我们可以设置为Res锁，当输入进程拿到Res锁的时候那么读进程就只能够等待直到输出进程释放了锁，当输入进程拿到锁之后那么输出进程就只能够等待直到输入进程释放了锁，最终加上锁之后那么输出结果是正确的：
public class Thread02 {
class Res{
// 共享对象
public String username;
public char sex;
}
// 输入线程
class InputThread extends Thread{
private Res res;
public InputThread(Res res){
this.res = res;
}
// 重写run()方法
@Override
public void run() {
int count = 0;
while (true){
synchronized (res){
if (count == 0){
res.username = "hexin";
res.sex = '男';
}else{
res.username = "xiaohong";
res.sex = '女';
}
count = (count + 1) % 2;
}
}
}
}
class OutputThread extends Thread{
@Override
public void run() {
while (true){
synchronized (res){
System.out.println(res.username + " " + res.sex);
}
}
}
private Res res;
public OutputThread(Res res){
this.res = res;
}
}
public static void main(String[] args) {
new Thread02().print();
}
public void print(){
// Res为全局共享变量
Res res = new Res();
InputThread inputThread = new InputThread(res);
OutputThread outputThread = new OutputThread(res);
// 启动输入线程和输出线程
inputThread.start();
outputThread.start();
}
}但是上面的代码输出一大段相同的人的名字和性别，我们希望的输出结果是隔一个输出一个人的名字和性别也即交替输出，由于输出线程可能会一直竞争到Res锁所以会一直输出一个人的名字和性别，对于输入线程也是类似的可能会一直获取到Res此时就会一直输入，如何进行改进呢？我们可以在全局变量Res中设置一个布尔值，如果为false则可以输入（输入线程可以操作），为true则可以输出（输出线程可以操作），当flag = false的时候此时是不能够输出的，输出线程拿到当前的Res锁之后需要释放掉当前的锁，此时调用res.wait()方法释放当前获取到的锁并且阻塞当前的线程，让输入线程可以获取到Res锁执行输入操作，当flag = true的时候并且输出线程获取到当前的Res锁此时输出对应的username和sex并且将flag = false，唤醒输入进程使得输入线程可以获取到当前的锁执行输入操作，同理当flag = true的时候输入线程获取到Res锁应该调用res.wait()方法释放当前获取到的锁，并且阻塞当前的线程让输出线程可以输出，当输入线程输入之后需要唤醒输出线程并将flag = true，通过加锁和wait()，notify()方法的配合使得输入线程和输出线程可以交替输出结果：
public class Thread02 {
class Res{
// 共享对象
public String username;
public char sex;
// 标记当前是由输入线程还是输出线程可以操作当前的Res变量
boolean flag = false;
}
// 输入线程
class InputThread extends Thread{
private Res res;
public InputThread(Res res){
this.res = res;
}
// 重写run()方法
@Override
public void run() {
int count = 0;
while (true){
synchronized (res){
// 当flag = true并且竞争到了当前的Res锁此时需要释放当前的锁, 阻塞当前的输入进程, 让输出线程可以获取到当前的锁, 调用res.wait()方法即可
if (res.flag == true){
try {
res.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if (count == 0){
res.username = "hexin";
res.sex = '男';
}else{
res.username = "xiaohong";
res.sex = '女';
}
count = (count + 1) % 2;
// 当输入进程输入完之后将标记设置为true, 唤醒输出线程
res.flag = true;
res.notify();
}
}
}
}
class OutputThread extends Thread{
@Override
public void run() {
while (true){
synchronized (res){
if (!res.flag){
// 需要释放掉当前的竞争得到的锁, 并且阻塞当前的线程让给输入线程操作
try {
res.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(res.username + " " + res.sex);
res.flag = false;
// 输出完当前的结果之后唤醒输入线程
res.notify();
}
}
}
private Res res;
public OutputThread(Res res){
this.res = res;
}
}
public static void main(String[] args) {
new Thread02().print();
}
public void print(){
// Res为全局共享变量
Res res = new Res();
InputThread inputThread = new InputThread(res);
OutputThread outputThread = new OutputThread(res);
// 启动输入线程和输出线程
inputThread.start();
outputThread.start();
}
}四. join()方法的底层原理
join() 底层原理是基于 wait()方法封装的，唤醒的代码在 jvm Hotspot 源码中，当jvm在关闭线程之前会检测先阻塞在 t1 线程对象上的线程，然后执行 notfiyAll()，这样 t2 就被唤醒了，同理线程t3也是也是类似的，通过join()方法就可以实现t1，t2，t3的执行顺序：
public class Thread03 {
public static void main(String[] args) {
// run方法执行完毕 唤醒t2 t2由阻塞转为竞争锁的状态
Thread t1 = new Thread(() ->
System.out.println(Thread.currentThread().getName() + ",线程执行")
, "t1");
// t2需要等待t1执行完毕
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
try {
// t1.wait(); t2调用 t1(this锁).wait() 主动释放this锁, 同时t2线程变为阻塞状态
t1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ",线程执行");
}
}, "t2");
// t3需要等待t2执行完毕
Thread t3 = new Thread(new Runnable() {
@Override
public void run() {
try {
t2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ",线程执行");
}
}, "t3");
t1.start();
t2.start();
t3.start();
}
}五. 多线程七种执行的状态
1.?初始化状态；2. 就绪状态；3. 运行状态；4. 死亡状态；5. 阻塞状态；6. 超时等待；7. 等待状态。start()：调用 start()方法会使得该线程开始执行，正确启动线程的方式；wait()：调用 wait()方法，进入等待状态，释放资源，让出 cpu，这个方法需要在同步代码块中调用；sleep()：调用 sleep()方法，进入超时等待，不释放资源，主动释放 cpu 执行权，休眠一段时间；stop()：调用 stop()方法，线程停止，线程不安全，不释放锁导致死锁，过时；join()：调用 join()方法，线程是同步，它可以使得线程之间的并行执行变为串行执行；yield()：暂停当前正在执行的线程对象，并执行其他线程，让出 cpu?资源可能立刻获得资源执行，yield()的目的是让相同优先级的线程之间能适当的轮转执行；notify()：在锁池随机唤醒一个线程，需要在同步代码块中调用；notifyAll()：唤醒锁池里所有的线程，需要在同步块中调用；Synchronized 没有获取到锁当前线程变为阻塞状态，如果有线程释放了锁，唤醒正在阻塞没有获取到锁的线程，重新进入到获取锁的状态。
下面是B站视频余胜军的画的关于多线程的七种执行状态
六. sleep()方法防止cpu占用100%
线程运行在cpu上，所以当出现死循环的时候cpu占用会非常高，可以在任务管理器中查看占用的cpu，可以使用Thread.sleep()方法让当前的进程暂时处于休眠的状态，可以防止cpu占用过高：
public class Thread {
public static void main(String[] args) {
new Thread(() -> {
while (true){
try {
Thread.sleep(30);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
}七. 守护线程和用户线程
java中线程分为两种类型：用户线程和守护线程。通过 Thread.setDaemon(false)设置为用户线程；通过 Thread.setDaemon(true)设置为守护线程。如果不设置次属性，默认为用户线程。
1. 守护线程是依赖于用户线程， 用户线程退出了，守护线程也就会退出，典型的守护线程如垃圾回收线程；
2. 用户线程是独立存在的，不会因为其他用户线程退出而退出。当前有一个主线程，主线程又创建了一个子线程，当主线程执行完毕之后，子线程还没有执行完，那么子线程不会因为主线程执行完而挂掉，当前创建的线程用户线程所以不会因为主线程挂掉而挂掉：
public class Thread04 {
public static void main(String[] args) {
new Thread(() -> {
while (true){
}
}, "子线程").start();
System.out.println("主线程");
}
}
若有一个需求当我们的主线程执行完成之后如何停止子线程呢？只要将设置为守护线程即可：
public class Thread04 {
public static void main(String[] args) {
Thread thread = new Thread(() -> {
while (true){
}
}, "子线程");
// 设置为守护线程
thread.setDaemon(true);
System.out.println("主线程");
}
}八. 如何安全停止一个线程
使用interupt()方法进行中断，结合isInterrupted()方法或者是标记位来停止一个线程：
public class Thread05 extends Thread{
@Override
public void run() {
while (true){
try {
System.out.println("1");
Thread.sleep(3000000);
// 中断之后没有执行到, 休眠状态中断之后会抛出一个异常
System.out.println("2");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) throws InterruptedException {
Thread05 thread = new Thread05();
thread.start();
Thread.sleep(3000);
System.out.println("中断当前的子线程");
// 中断, 阻塞当前正在运行的线程
thread.interrupt();
}
}public class Thread05 extends Thread{
@Override
public void run() {
while (true){
if (this.isInterrupted()){
break;
}
}
}
public static void main(String[] args) throws InterruptedException {
Thread05 thread = new Thread05();
thread.start();
Thread.sleep(3000);
System.out.println("中断当前的子线程");
// 中断, 阻塞当前正在运行的线程
thread.interrupt();
}
}
九. Lock锁
1. Synchronized 锁与Lock区别
推荐使用Synchronized 锁，因为Synchronized 锁在底层做了优化，特别是锁升级，Synchronized ---属于 jdk?关键字，底层属于c++虚拟机底层实现，Lock 锁底层基于 AQS 实现---?变为重量级
Synchronized 底层原理---锁的升级过程；Lock锁在使用的过程中需要注意获取锁，释放锁；
2. Lock锁的使用
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
// 获取锁和释放锁由开发人员自己定义
public class Thread06 {
private Lock lock = new ReentrantLock();
public static void main(String[] args) throws InterruptedException {
Thread06 thread06 = new Thread06();
thread06.print1();
Thread.sleep(300);
System.out.println("线程2开始抢锁");
thread06.print2();
}
private void print1(){
new Thread(new Runnable() {
@Override
public void run() {
try {
lock.lock();
System.out.println(Thread.currentThread().getName() + "获取锁成功");
}catch (Exception e){
e.printStackTrace();
}finally {
// 释放锁, 这样线程2才可以获取到这把锁
lock.unlock();
}
}
}, "t1").start();
}
private void print2(){
new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println(Thread.currentThread().getName() + " 1");
lock.lock();
System.out.println(Thread.currentThread().getName() + " 2");
}catch (Exception e){
e.printStackTrace();
}
}
}, "t2").start();
}
}3. Lock锁的通信（类似于synchronized锁的wait()和notify()方法的思想）
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Thread07 {
private Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
public static void main(String[] args) {
Thread07 thread07 = new Thread07();
thread07.cal();
try {
Thread.sleep(3000);
} catch (Exception e) {}
thread07.signal();
}
public void signal() {
try {
lock.lock();
condition.signal();
} catch (Exception e) {
} finally {
lock.unlock();
}
}
public void cal() {
new Thread(new Runnable() {
@Override
public void run() {
// 主动释放锁 同时当前线程变为阻塞状态
try {
lock.lock();
System.out.println("1");
// 注意是await()方法
condition.await();
System.out.println("2");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}).start();
}
}十. 多线程yield
yield()方法主动释放 cpu 执行权
1. 多线程 yield 会让线程从运行状态进入到就绪状态，让后调度执行其他线程。
2. 具体的实现依赖于底层操作系统的任务调度器，具体的结果还需要由cpu的任务调度器来决定是否让出cpu执行权：
public class Thread08 extends Thread {
public Thread08(String name) {
super(name);
}
@Override
public void run() {
for (int i = 0; i < 50; i++) {
if (i == 30) {
System.out.println(Thread.currentThread().getName() + ", 释放cpu执行权");
yield();
}
System.out.println(Thread.currentThread().getName() + "," + i);
}
}
public static void main(String[] args) {
new Thread08("thread1").start();
new Thread08("thread2").start();
}
}
