一、共享带来的问题

1. 临界区

（1）一个程序运行多个线程本身是没有问题的

（2）问题出在多个线程访问共享资源

1️⃣多个线程读共享资源其实也没有问题

2️⃣在多个线程对共享资源读写操作时发送指令交错，就会出现问题

（3）一段代码块内如果存在对共享资源的多线程读写操作，称这段代码块为临界区

2. 竞态条件 Race Condition

多个线程在临界区内执行，由于代码的执行序列不同而导致结果无法预测，称之为发生了竞态条件

二、Synchronized 解决方案（P54）

1. 应用之互斥

为了避免临界区的竞态条件发生，有多种手段可以达到目的。

（1）阻塞式的解决方案：synchronized、Lock

（2）非阻塞式的解决方案：原子变量

synchronized，即俗称的【对象锁】，它采用互斥的方式让同一时刻至多只有一个线程能持有对象锁，其他线程再想获取这个对象锁时就会阻塞住。这样就能保证拥有锁的线程可以安全的执行临界区内的代码，不用担心线程上下文切换。

注意：

虽然 Java 中互斥和同步都可以采用 synchronized 关键字来完成，但有区别：

（1）互斥是保证临界区的竞态条件发生，同一时刻只能有一个线程执行临界区代码。

（2）同步是由于线程执行的先后顺序不同，需要一个线程等待其他线程运行到某个点。

2. synchronized

synchronized(对象) // 线程1， 线程2(blocked)
{
     临界区
}

@Slf4j(topic = "c.Test17")
public class Test17 {
    static int counter = 0;
    static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                synchronized (lock) {
                    counter++;
                }
            }
        },"t1");

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                synchronized (lock) {
                    counter--;
                }
            }
        },"t2");

        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("{}",counter);

    }
}

思考：

synchronized 实际是用对象锁保证了临界区内代码的原子性，临界区内的代码对外是不可分割的，不会被线程切换所打断。

3. 面向对象改进

@Slf4j(topic = "c.Test17")
public class Test17 {
    public static void main(String[] args) throws InterruptedException {
        Room room = new Room();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                room.increment();
            }
        }, "t1");

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                room.decrement();
            }
        }, "t2");

        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("{}", room.getCounter());
    }
}

class Room {
    private int counter = 0;

    public synchronized void increment() {
        counter++;
    }

    public synchronized void decrement() {
        counter--;
    }

    public synchronized int getCounter() {
        return counter;
    }
}