1.前言
当我们使用多个线程访问同一资源时(可以是同一变量，同一文件，同一条记录)，若多个线程只要只读操作，则不会发生线程安全问题;如果多个线程既有可读又有可写操作时，将可能导致线程安全问题.
2.提出问题
例 : 三个人对银行账户存储的100块存款进行取钱，如果该账户还有存款，就可以取.该问题可能发生线程安全问题吗？
3.继承Thread类的方式进行模拟 :
public class ThreadTest { public static void main(String[] args) { MulterThread t1 = new MulterThread("线程-1"); MulterThread t2 = new MulterThread("线程-2"); MulterThread t3 = new MulterThread("线程-3"); t1.start(); t2.start(); t3.start(); } } class MulterThread extends Thread { static int change = 100; public MulterThread() { super(); } public MulterThread(String name) { super(name); } @Override public void run() { while(true) { if (change > 0) { System.out.println(Thread.currentThread().getName() + "\t\t" + change); change--; } else { break; } } } } 控制台 : //显然有问题，100的时候被取的两次 线程-2 100 线程-1 100 线程-2 99 线程-1 98 线程-2 97 线程-1 96 线程-2 95 线程-1 94 线程-1 92 线程-2 93 略
注 :
- 为什么change变量要声明为static : 如果不声明为static，那么new了三个MulterThread对象，就会有300块的存款，与抢占同一资源的场景不符.
- 为什么会出现两次100呢 : 很显然，每次运行结果不一样，按该次运行结果举例.当线程2调用run()方法进入输出语句的时候，执行到下一句change--还需要一段时间，而此时线程1也调用了run()，并也执行到了输出语句，此时change--语句并未执行，所以二者都打印的是100.
3.实现Runnable接口的方法进行模拟
public class RunnableTest { public static void main(String[] args) { A a = new A(); Thread t1 = new Thread(a); Thread t2 = new Thread(a); Thread t3 = new Thread(a); t1.start(); t2.start(); t3.start(); } } class A implements Runnable{ int change = 100; @Override public void run() { while (true) { if (change > 0) { System.out.println(Thread.currentThread().getName() + "\t\t" + change); change--; } else { break; } } } } 控制台 : Thread-1 100 Thread-1 99 Thread-1 98 Thread-0 100 Thread-1 97 Thread-0 96 Thread-2 100 Thread-0 94 Thread-1 95 Thread-1 91 略
注 :
- 为什么change变量不用static修饰 : 只调用一次new创建了A的一个对象，并作为同一个实参传入到Thread类中.因为只new了一次，所以change只有一份.
- 为什么会出现三次100 : 与上同.
4.解决方案
必须满足一个线程在操作change时，其他线程必须等待，直到该线程操作完成后，其他线程才可以进来操作change.
5.方式1 : 同步代码块
(1). 格式
synchronized(同步监视器){ //需要被同步的代码 }
(2). 利用同步监视器来解决继承Thread类带来的线程安全问题.
注 : 为什么该处同步监视器不用this，而是用MulterThread.class呢?
因为创建了三个Thread类对象，this表示调用run方法的实例对象，三个对象都启动线程调用run方法，this有可能是t1，t2，t3，并不唯一.
@Override public void run() { while(true) { synchronized (MulterThread.class){ if (change > 0) { System.out.println(Thread.currentThread().getName() + "\t\t" + change); change--; } else { break; } } } }
(3). 利用同步监视器来解决实现接口带来的线程安全问题 :
@Override public void run() { while (true) { synchronized (this){ if (change > 0) { System.out.println(Thread.currentThread().getName() + "\t\t" + change); change--; } else { break; } } } }
说明 :
- 需要被同步的代码，即为操作共享数据的代码.
- 共享数据 : 即多个线程可以操作的数据 : 如该处的change.
- 需要被同步的代码，在被synchronized包裹后，就使得一个线程操作共享数据时，其他线程需等待.
- 同步监视器 : 哪个线程获得了锁，哪个线程就可以执行被同步的代码.
- 同步监视器可以由任何对象充当，但必须多个线程共用同一个同步监视器.(即该监视器必须唯一).
- 继承Thread类 : 同步监视器----＞类名.class
- 实现接口 : 同步监视器------＞this
6.同步方法
public synchronized void Xxx(){ //被同步的代码 }
由于同步方法的同步监视器默认是this，所以更适用于实现Runnable接口的方式.(如果是继承Thread类的方式，this一般不唯一.)
如果该方法是静态同步方法，默认的则是该类
boolean isFlag = true; @Override public void run() { while (isFlag) { show(); } } //同步方法 //默认的同步监视器是this public synchronized void show() { if (change > 0) { System.out.println(Thread.currentThread().getName() + "\t\t" + change); change--; } else { isFlag = false; } }
7.同步监视器
同步监视器（Synchronized Monitor）是Java中一种内置的同步机制，用于确保多个线程对共享资源的互斥访问。当一个线程进入一个被synchronized修饰的方法或代码块时，它会获取一个同步监视器对象，其他线程必须等待该线程释放监视器才能继续执行。
问题 : 同步监视器不唯一会导致锁不住的问题
因为在Java中，每个对象都有一个内置的锁（也称为监视器锁），当多个线程尝试访问同一个对象的同步方法或同步代码块时，这些线程需要竞争这个锁。如果同步监视器不唯一，那么可能会出现多个线程同时持有不同对象的锁，从而导致锁不住的问题。
