线程安全问题
1，观察代码（存在线程安全问题）
public class ThreadDemo { private static class Counter { private long n = 0; public void increment() { n++; } public void decrement() { n--; } public long value() { return n; } } public static void main(String[] args) throws InterruptedException { final int COUNT = 1000_0000; Counter counter = new Counter(); Thread thread = new Thread(() -> { for (int i = 0; i < COUNT; i++) { counter.increment(); } }, "李四"); thread.start(); for (int i = 0; i < COUNT; i++) { counter.decrement(); } thread.join(); // 期望最终结果应该是 0 System.out.println(counter.value()); }}
如果你对多线程有一点了解的话，肯定会看出其中的问题吧！
在代码中，启用了一个子线程对变量n++了count次，main线程对变量n–了count次，按照预期结果应该最终结果是0，但是实际执行结果到底是什么，我也不知道，我想应该没人知道吧，你说呢？
语言 方法
7265 zru6mF649j
7QA2g抖音公会
8519 .02.07 20-37-25
哈哈哈？为什么呢，学完下面你就知道了。
2，线程安全的概念
想给出一个线程安全的确切定义是复杂的，但我们可以这样认为：
如果多线程环境下代码运行的结果是符合我们预期的，即在单线程环境应该的结果，则说这个程序是线程安全的。
3， 线程不安全的原因
3.1 原子性
上图中为火车票售票系统，AB客户端同时运行，A检测到票数为1，将票售出，还没有将更新数据写入数据库时，B检测到票数为1,也将票售出，这样，一张票就被卖了两次。
什么是原子性
我们把一段代码想象成一个房间，每个线程就是要进入这个房间的人。如果没有任何机制保证，A进入房间之后，还 没有出来；B 是不是也可以进入房间，打断 A 在房间里的隐私。这个就是不具备原子性的。
那我们应该如何解决这个问题呢？是不是只要给房间加一把锁，A 进去就把门锁上，其他人是不是就进不来了。这样 就保证了这段代码的原子性了。
有时也把这个现象叫做同步互斥，表示操作是互相排斥的
一条 java 语句不一定是原子的，也不一定只是一条指令
比如刚才我们看到的 n++，其实是由三步操作组成的：
从内存把数据读到 CPU
进行数据更新
把数据写回到 CPU
不保证原子性会给多线程带来什么问题
如果一个线程正在对一个变量操作，中途其他线程插入进来了，如果这个操作被打断了，结果就可能是错误的。
那么学到这里，你是不是对刚开始的问题有了一定的见解了呢？？？
3.2 可见性
主内存-工作内存
为了提高效率，JVM在执行过程中，会尽可能的将数据在工作内存中执行，但这样会造成一个问题，共享变量在多线 程之间不能及时看到改变，这个就是可见性问题。
3.3 代码顺序性
什么是代码重排序
一段代码是这样的：
去宿舍取下 U 盘
去教室写 10 分钟作业
去宿舍取下水杯
如果是在单线程情况下，JVM、CPU指令集会对其进行优化，比如，按 1->3->2的方式执行，也是没问题，可以少跑 一次宿舍。这种叫做指令重排。
public class ThreadDemo { private static class Counter { private int n1 = 0; private int n2 = 0; private int n3 = 0; private int n4 = 0; private int n5 = 0; private int n6 = 0; private int n7 = 0; private int n8 = 0; private int n9 = 0; private int n10 = 0; public void write() { n1 = 1; n2 = 2; n3 = 3; n4 = 4; n5 = 5; n6 = 6; n7 = 7; n8 = 8; n9 = 9; n10 = 10; } public void read() { System.out.println("n1 = " + n1); System.out.println("n2 = " + n2); System.out.println("n3 = " + n3); System.out.println("n4 = " + n4); System.out.println("n5 = " + n5); System.out.println("n6 = " + n6); System.out.println("n7 = " + n7); System.out.println("n8 = " + n8); System.out.println("n9 = " + n9); System.out.println("n10 = " + n10); } } public static void main(String[] args) { Counter counter = new Counter(); Thread thread1 = new Thread(() -> { counter.read(); }, "读"); Thread thread2 = new Thread(() -> { counter.write(); }, "写"); thread1.start(); thread2.start(); }}
代码重排序会给多线程带来什么问题
刚才那个例子中，单线程情况是没问题的，优化是正确的，但在多线程场景下就有问题了，什么问题呢。可能水杯是在你写作业的10分钟内被舍友过来的，如果指令重排序了，代码就会是错误的。
4 解决之前的线程不安全问题
public class ThreadDemo { private static class Counter { private long n = 0; public synchronized void increment() { n++; } public synchronized void decrement() { n--; } public synchronized long value() { return n; } } public static void main(String[] args) throws InterruptedException { final int COUNT = 1000_0000; Counter counter = new Counter(); Thread thread = new Thread(() -> { for (int i = 0; i < COUNT; i++) { counter.increment(); } }, "李四"); thread.start(); for (int i = 0; i < COUNT; i++) { counter.decrement(); } thread.join(); // 期望最终结果应该是 0 System.out.println(counter.value()); }}
这里的方式主要是给每个方法，添加了synchronized关键字，解决了存在的线程安全问题，那么是如何做到的呢？？？，下面来专门看一下。
5， synchronized 关键字-监视器锁monitor lock
synchronized的底层是使用操作系统的mutex lock实现的。
当线程释放锁时，JMM会把该线程对应的工作内存中的共享变量刷新到主内存中
当线程获取锁时，JMM会把该线程对应的本地内存置为无效。从而使得被监视器保护的临界区代码必须从主内 存中读取共享变量
synchronized用的锁是存在Java对象头里的。
synchronized同步快对同一条线程来说是可重入的，不会出现自己把自己锁死的问题；
同步块在已进入的线程执行完之前，会阻塞后面其他线程的进入。
锁的 SynchronizedDemo 对象
public class SynchronizedDemo { public synchronized void methond() {} public static void main(String[] args) { SynchronizedDemo demo = new SynchronizedDemo(); demo.method(); // 进入方法会锁 demo 指向对象中的锁；出方法会释放 demo 指向的对象中的锁 } }
锁的 SynchronizedDemo 类的对象
public class SynchronizedDemo { public synchronized static void methond() { } public static void main(String[] args) { method(); // 进入方法会锁 SynchronizedDemo.class 指向对象中的锁；出方法会释放 SynchronizedDemo.class 指向的对象中的锁 } }
明确锁的对象
public class SynchronizedDemo { public void methond() { // 进入代码块会锁 this 指向对象中的锁；出代码块会释放 this 指向的对象中的锁 synchronized (this) { } } public static void main(String[] args) { SynchronizedDemo demo = new SynchronizedDemo(); demo.method(); }} public class SynchronizedDemo { public void methond() { // 进入代码块会锁 SynchronizedDemo.class 指向对象中的锁；出代码块会释放 SynchronizedDemo.class 指向的对象中的锁 synchronized (SynchronizedDemo.class) { } } public static void main(String[] args) { SynchronizedDemo demo = new SynchronizedDemo(); demo.method(); } } 6. volatile 关键
修饰的共享变量，可以保证可见性，部分保证顺序性
class ThraedDemo { private volatile int n;}
作用：
（1）保证可见性：变量都是从主内存进行操作
（2）禁止指令重排序，建立内存屏障
注意事项：
不保证原子性
如果一个变量的操作不会分解为多条指令，就是线程安全，否则就是线程不安全。
如何判断变量的操作会不会分解为多条指令呢？？？
依赖某个共享变量的值进行修改操作就会分解
》例如： n++,n–,++n,–n,!flag,new 对象都是非线程安全
7， 通信-对象的等待集wait set
1.wait()的作用是让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。“直到其他线程调用此 对象的 notify() 方法或 notifyAll() 方法”，当前线程被唤醒(进入“就绪状态”)
2.notify()和notifyAll()的作用，则是唤醒当前对象上的等待线程；notify()是唤醒单个线程，而notifyAll()是唤醒所有的 线程。
3.wait(long timeout)让当前线程处于“等待(阻塞)状态”，“直到其他线程调用此对象的notify()方法或 notifyAll() 方法， 或者超过指定的时间量”，当前线程被唤醒(进入“就绪状态”)。
7.1 wait()方法
其实wait()方法就是使线程停止运行。
方法wait()的作用是使当前执行代码的线程进行等待，wait()方法是Object类的方法，该方法是用来将当前线程 置入“预执行队列”中，并且在wait()所在的代码处停止执行，直到接到通知或被中断为止。
wait()方法只能在同步方法中或同步块中调用。如果调用wait()时，没有持有适当的锁，会抛出异常。
wait()方法执行后，当前线程释放锁，线程与其它线程竞争重新获取锁。
范例：观察wait()方法使用
public static void main(String[]args)throws InterruptedException{ Object object=new Object(); synchronized (object){ System.out.println("等待中..."); object.wait();System.out.println("等待已过..."); } System.out.println("main方法结束...");}
这样在执行到object.wait()之后就一直等待下去，那么程序肯定不能一直这么等待下去了。这个时候就需要使用到了 另外一个方法唤醒的方法notify()。
7.2 notify()方法
notify方法就是使停止的线程继续运行。
方法notify()也要在同步方法或同步块中调用，该方法是用来通知那些可能等待该对象的对象锁的其它线程，对 其发出通知notify，并使它们重新获取该对象的对象锁。如果有多个线程等待，则有线程规划器随机挑选出一个 呈wait状态的线程。
在notify()方法后，当前线程不会马上释放该对象锁，要等到执行notify()方法的线程将程序执行完，也就是退出 同步代码块之后才会释放对象锁。
范例：使用notify()方法唤醒线程
class MyThread implements Runnable { private boolean flag; private Object obj; public MyThread(boolean flag, Object obj) { super(); this.flag = flag; this.obj = obj; } public void waitMethod() { synchronized (obj) { try { while (true) { System.out.println("wait()方法开始.. " + Thread.currentThread().getName()); obj.wait(); System.out.println("wait()方法结束.. " + Thread.currentThread().getName()); return; } } catch (Exception e) { e.printStackTrace(); } } } public void notifyMethod() { synchronized (obj) { try { System.out.println("notify()方法开始.. " + Thread.currentThread().getName()); obj.notify(); System.out.println("notify()方法结束.. " + Thread.currentThread().getName()); } catch (Exception e) { e.printStackTrace(); } } } @Override public void run() { if (flag) { this.waitMethod(); } else { this.notifyMethod(); } }}public class TestThread { public static void main(String[] args) throws InterruptedException { Object object = new Object(); MyThread waitThread = new MyThread(true, object); MyThread notifyThread = new MyThread(false, object); Thread thread1 = new Thread(waitThread, "wait线程"); Thread thread2 = new Thread(notifyThread, "notify线程"); thread1.start(); Thread.sleep(1000); thread2.start(); System.out.println("main方法结束!!"); }}
从结果上来看第一个线程执行的是一个waitMethod方法，该方法里面有个死循环并且使用了wait方法进入等待状态 将释放锁，如果这个线程不被唤醒的话将会一直等待下去，这个时候第二个线程执行的是notifyMethod方法，该方 法里面执行了一个唤醒线程的操作，并且一直将notify的同步代码块执行完毕之后才会释放锁然后继续执行wait结束 打印语句。
注意：wait，notify必须使用在synchronized同步方法或者代码块内
7.3 notifyAll()方法
以上讲解了notify方法只是唤醒某一个等待线程，那么如果有多个线程都在等待中怎么办呢，这个时候就可以使用 notifyAll方法可以一次唤醒所有的等待线程，看示例。
范例：使用notifyAll()方法唤醒所有等待线
class MyThread implements Runnable { private boolean flag; private Object obj; public MyThread(boolean flag, Object obj) { super(); this.flag = flag; this.obj = obj; } public void waitMethod() { synchronized (obj) { try { while (true) { System.out.println("wait()方法开始.. " + Thread.currentThread().getName()); obj.wait(); System.out.println("wait()方法结束.. " + Thread.currentThread().getName()); return; } } catch (Exception e) { e.printStackTrace(); } } } public void notifyMethod() { synchronized (obj) { try { System.out.println("notifyAll()方法开始.. " + Thread.currentThread().getName()); obj.notifyAll(); System.out.println("notifyAll()方法结束.. " + Thread.currentThread().getName()); } catch (Exception e) { e.printStackTrace(); } } } @Override public void run() { if (flag) { this.waitMethod(); } else { this.notifyMethod(); } }}public class TestThread { public static void main(String[] args) throws InterruptedException { Object object = new Object(); MyThread waitThread1 = new MyThread(true, object); MyThread waitThread2 = new MyThread(true, object); MyThread waitThread3 = new MyThread(true, object); MyThread notifyThread = new MyThread(false, object); Thread thread1 = new Thread(waitThread1, "wait线程A"); Thread thread2 = new Thread(waitThread2, "wait线程B"); Thread thread3 = new Thread(waitThread3, "wait线程C"); Thread thread4 = new Thread(notifyThread, "notify线程"); thread1.start(); thread2.start(); thread3.start(); Thread.sleep(1000); thread4.start(); System.out.println("main方法结束!!"); }}
现在可以看出notifyAll确实是唤醒了所有线程了。
注意：唤醒线程不能过早，如果在还没有线程在等待中时，过早的唤醒线程，这个时候就会出现先唤醒，在等待的效果了。这样 就没有必要在去运行wait方法了。
7.4 wait 和 sleep 的对比（面试题）
其实理论上 wait 和 sleep 完全是没有可比性的，因为一个是用于线程之间的通信的，一个是让线程阻塞一段时间， 唯一的相同点就是都可以让线程放弃执行一段时间。说白了放弃线程执行只是 wait 的一小段现象。
面试总结：
wait 之前需要请求锁，而wait执行时会先释放锁，等被唤醒时再重新请求锁。这个锁是 wait 对象上的 monitor lock
sleep 是无视锁的存在的，即之前请求的锁不会释放，没有锁也不会请求。
wait 是 Object 的方法
sleep 是 Thread 的静态方法
