目录
[1.3中断线程--interrupt() 方法](#1.3中断线程--interrupt() 方法)
[2.3 synchronized和volatile的区别](#2.3 synchronized和volatile的区别)
🎁个人主页：tq02的博客_CSDN博客-C语言,Java,Java数据结构领域博主
🎥 本文由 tq02 原创，首发于 CSDN🙉
🎄 本章讲解内容：多 线程的控制、安全讲解
前言
JavaEE的多线程知识点，我们在多线程(1)中学习到了如何创建多线程、多线程的运行状态等，而本章主要讲解多线程的线程控制手段以及线程安全。
一.线程控制方法
线程控制：就是控制线程的执行速率，让某某线程先执行等。 根据生命周期，我们可以知道线程控制方法大概有：start()、sleep()、interrupt()、join()、wait()、yield()、notify()、
1.1启动线程--start()
java
class MyThread extends Thread {
@Override
public void run() {
System.out.println("这里是线程运行的代码");
}
}
public class Text{
public static void main(String[] args) {
//创建MyThread实例
MyThread t1=new MyThread();
//调用start方法启动线程
t1.start();
//t1.run(); 虽然也是执行run函数当中的操作，但是并不是启动线程，而是调用方法
}
} 通过覆写 run 方法创建一个线程对象，但线程对象被创建出来并不意味着线程就开始运行了。并且不是指调用run方法就可以使用线程运行，而是单纯的执行方法run，并不能达到并行的机制，只有使用start()方法才可以使线程运行
1.2线程睡眠---sleep()方法
线程会暂停运行，并且可以设置暂停运行的时间，例如：sleep(1000),是休眠了1秒。
注：是暂停运行，而不是停止运行，而时间的设置长度更像是闹钟，时间一到，就开始运行。
1.3中断线程--interrupt() 方法
线程一旦开始运行，想让线程强制停止，目前有2种方法。
- 通过共享的标记来进行沟通
- 调用**interrupt()**方法来通知
1.通过共享的标记来进行沟通：
使用自定义的变量来作为标志位.并且给标志位上并且final修饰，后期会讲解volatile 关键字，使用它也可以执行操作。
java
public class Text{
// 写作成员变量就不是触发变量捕获的逻辑了. 而是 "内部类访问外部类的成员" ,
//本身就是 ok 的~~
public static boolean isQuit = false;
public static void main(String[] args) throws InterruptedException {
//或者 final boolean isQuit = false；
Thread t = new Thread(() -> {
while (!isQuit) {
System.out.println("hello thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t.start();
// 主线程这里执行一些其他操作之后, 要让 t 线程结束.
Thread.sleep(3000);
// 这个代码就是在修改前面设定的标志位.
isQuit = true;
System.out.println("把 t 线程终止");
}
} 从上面的代码当中，我们可以发现isQuit变量用于lambda表达式，因此会有一个变量捕获的环节，而在变量捕获当中，捕获到的外部变量isquit不可以修改，因此需要使用final修饰，主线程执行完毕时，将isQuit修改为true;导致子线程强行结束。
2.调用 interrupt() 方法来通知
Thread.interrupted() 或者 Thread.currentThread().isInterrupted() 代替自定义标志位.
**Thread.currentThread():**获取当前对象的引用，isInterrupted()方法是指提供一个标志位。
Thread.interrupted(): 将标志位改为true
java
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(() -> {
// Thread.currentThread 就是 t .
// 但是 lambda 表达式是在构造 t 之前就定义好的. 编译器看到的 lambda 里的 t 就会认为这是一个还没初始化的对象.因此wile的括号里不可以使用t.
while (!Thread.currentThread().isInterrupted()) {
System.out.println("hello thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// e.printStackTrace();
break;
}
}
});
t.start();
Thread.sleep(3000);
// 把上述的标志位给设置成 true
t.interrupt();
}当线程正在sleep()休眠当中，如果使用interrupt()唤醒，则会唤醒，继续运行
1.4等待线程---join()
等待线程，是指两个线程进行时，一个线程等待另一个线程执行结束，才可以执行结束。
java
public static void main(String[] args) {
Thread b = new Thread(() -> {
for (int i = 0; i < 5; i++) {
System.out.println("张三工作");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("张三工作结束了");
});
Thread a = new Thread(() -> {
for (int i = 0; i < 3; i++) {
System.out.println("李四工作");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
// 如果 b 此时还没执行完毕, b.join 就会产生阻塞的情况
b.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("李四工作结束了");
});
b.start();
a.start();
}例如，原本李四工作比张三工作要快，可是我使用了join()方法，然后让李四等待张三结束，才能结束。方法还可以使用其他参数用于不同意思。
|-------------------|---------------------|
| 方法 | 作用 |
| join() | 等待线程结束 |
| jion(long millis) | 等待线程结束，或者等待一定时间自动结束 |
而除了这些操作方法之外，我们还有wait()、notify()方法，但是需要先学习线程安全才能更好的学习。
二.线程安全
线程安全指：多线程环境下代码运行的结果是符合我们预期的，即在单线程环境应该的结果，则说这个程序是线程安全的。
线程不安全出现的根本原因：
- 线程是抢占式执行
- 多个线程同时对共享数据进行操作，产生数据覆盖
- 内存可见性
- 指令重排序
2.1数据不安全---数据共享
⭐不安全的演示和原因
java
class Counter {
public int count = 0;
void increase() {
count++;
}
}
public static void main(String[] args) throws InterruptedException {
final Counter counter = new Counter();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 50000; i++) {
counter.increase();
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 50000; i++) {
counter.increase();
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(counter.count);
}例如：以上2个线程，都执行50000次的count++，按理而言count最后的结果是100000次，可是执行之后却不足100000次。数据会存放在堆区，多个线程都可以访问。
出现的原因
count++实际上操作：
- 内存的数据加载到CPU寄存器中
- 寄存器中的数据执行++
- 返回给内存。
由于count在堆上，会被多个线程共享访问， t1和t2线程同时获取count元素，进行自增，然后将结果返回内存器当中，t1返回2，t2页返回2，将t1返回的值覆盖，因此少了一次自增
⭐不安全的处理方法
线程不安全的原因主要是多个线程会共享访问数据，导致数据的原子性被破坏，因此我们可以使用一种方法，让其他线程知晓该数据正在被其他线程使用(可见性)。
方法 ：加锁
当一个线程在执行操作时，对需要操作的数据或者方法进行加锁，这样其他线程使用不到了。
例如，需要操作的方法或者数据是一个房间，线程一进去时，将门锁了，只有线程一操作结束，出来时，线程二才能进去
使用关键字synchronized，加锁操作：
java
class Counter {
public int count = 0;
synchronize void increase() {
count++;
}
}
public static void main(String[] args) throws InterruptedException {
final Counter counter = new Counter();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 50000; i++) {
counter.increase();
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 50000; i++) {
counter.increase();
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(counter.count);
}将increase()方法进行加锁，当一个线程进入时，就会进行加锁，其他线程只能等待该线程释放。
⭐synchronized的使用
synchronized关键字进行加锁时，是需要对相同的对象 展开。
加锁的目的：为了互斥使用资源，而加锁的对象也是需要相同的，两个线程对同一个对象进行加锁时，会产生锁竞争/锁冲突。
java
class Counter {
public int count = 0;
void increase() {
synchronized(this){
count++;
}
}
}this是目前对象，而我们也可以使用其他对象。
2.2数据不安全---内存可见性
⭐不安全的演示和原因
java
static class Counter {
public int flag = 0;
}
public static void main(String[] args) {
Counter counter = new Counter();
Thread t1 = new Thread(() -> {
while (counter.flag == 0) {
//代码操作
}
System.out.println("循环结束!");
});
Thread t2 = new Thread(() -> {
Scanner scanner = new Scanner(System.in);
System.out.println("输入一个整数:");
counter.flag = scanner.nextInt();
});
t1.start();
t2.start();
}在这个代码中，我们只需要输入非零数，按逻辑而言，线程t1也应该会结束，可事实上，t1不会结束，**原因：**t1读取自己工作内存中的内容，而t2对flag进行修改，t1却无法得知他的修改。
问题产生的原因：
- counter.flag==0；实际上的指令：load(读指令）jcmp(比较指令)
- 编译器发现这个这个逻辑是一样的，每一次都是需要读取指令，结果却是一样的，因此，编译器会将逻辑优化掉，直接进行jcmp指令。
- 因此即使flag发生了改变，t1也无法得知。
⭐不安全的处理方法
使用volatile关键字，使用volatile关键字修饰变量之后，编译器就会禁止优化。
java
static class Counter {
public volatile int flag = 0;
}
public static void main(String[] args) {
Counter counter = new Counter();
Thread t1 = new Thread(() -> {
while (counter.flag == 0) {
//代码操作
}
System.out.println("循环结束!");
});
Thread t2 = new Thread(() -> {
Scanner scanner = new Scanner(System.in);
System.out.println("输入一个整数:");
counter.flag = scanner.nextInt();
});
t1.start();
t2.start();
}本质上保证修饰的变量的内存可见性，禁止编译器的优化
2.3 synchronized和volatile的区别
- volatile不保证原子性，只保证了内存可见性
- synchronized保证了原子性、也保证了内存可见性
三.认识wait()、notify()
由于线程之间是抢占式执行的，因此线程之间执行的先后顺序难以预知。但是实际开发中，我们希望可以协调控制多个线程的执行先后顺序。
而涉及到协调控制方法：
- wait() / wait(long timeout)：让线程进入等待状态
- notify() / notifyAll(): 唤醒在当前对象上等待的线程
3.1wait()方法
线程进入等待状态，如果没有唤醒，则会一直一直等待，并且需要搭配synchronized 来使用. 脱离 synchronized 使用 wait 会直接抛出异常.
wait()结束等待的条件：
- 其他线程调用该对象的 notify 方法.
- wait 等待时间超时 (wait 方法提供一个带有 timeout 参数的版本, 来指定等待时间).
- 其他线程调用该等待线程的 interrupted 方法, 导致 wait 抛出 InterruptedException 异常.
代码示例：
java
public static void main(String[] args) throws InterruptedException {
Object object = new Object();
synchronized (object) {
System.out.println("等待中");
object.wait();
System.out.println("等待结束");
}
}3.2notify()方法
用于唤醒wait()进入等待的线程。在notify()方法后，当前线程不会马上释放该对象锁，要等到执行notify()方法的线程将程序执行完，也就是退出同步代码块之后才会释放对象锁。
notifyAll()方法:则是唤醒所有等待的线程。注：虽然是同时唤醒，但是需要竞争锁，因此并不是同时执行，依然有先来后到的执行
3.3wait()方法和sleep()方法的对比
理论上 wait 和 sleep 完全是没有可比性的，因为一个是用于线程之间的通信的，一个是让线程阻塞一段时间，唯一的相同点就是都可以让线程放弃执行一段时间
wait 需要搭配 synchronized 使用. sleep 不需要.
wait 是 Object 的方法 sleep 是 Thread 的静态方法.
四.总结
volatile 能够保证内存可见性. 强制从主内存中读取数据，synchronize既可以保证原子性也可以保证内存可见性。
Java多线程实现数据共享的原理：
JVM 把内存分成了这几个区域:
方法区, 堆区, 栈区, 程序计数器.
其中堆区这个内存区域是多个线程之间共享的.
只要把某个数据放到堆内存中, 就可以让多个线程都能访问到