synchronized：同步的

例：取钱

不做线程同步的场合，假设骗子和户主同时取钱，可能出现这种情况：

• 【骗子】取款2000：账户余额1000
• 【户主】取款2000：账户余额1000
• 结果是社会财富增加1000，银行不开心。

代码如下所示：

// 账户类
class Account {
    private int accountBalance = 2000;
    public void withdraw(String userName, int amount) {
        System.out.println(userName + "===in===");
        if (accountBalance >= amount) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            accountBalance -= amount;// 取钱
            System.out.println(userName + "取款" + amount + "，余额：" + accountBalance);
        } else {
            System.out.println(userName + "企图取款" + amount + "，但余额只有：" + accountBalance);
        }
        System.out.println(userName + "===out===");
    }
}
class MyThread extends Thread {
    @Override
    public void run() {
        取钱Demo.act.withdraw(getName(), 1000);
    }
}
public class 取钱Demo {
    static Account act = new Account();// 账户就一份
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        t1.setName("户主");
        t2.setName("骗子");
        t2.start();
        t1.start();
    }
}

---

想要银行开心，就需要对线程进行同步处理，避免出现重复取款的情况。

---

线程同步

方法一：锁对象

    public void withdraw(String userName, int amount) {
        synchronized (this) {
          ……
        }
    }

如果是静态方法，没有this，则是锁住【类名.class】

    public static void withdraw(String userName, int amount) {
        synchronized (Account.class) {
          ……
        }
    }

方法二：锁方法

当方法被调用时，调用线程必须获得当前对象的锁，否则将等待下去。

方法结束后，锁会被释放。

public synchronized void withdraw(String userName, int amount) {...}

---

方法三：ReentrantLock重入锁

ReentrantLock是java.util.concurrent.locks.Lock接口的一个实现类。（reentrant：[rɪ'entrənt]再进去）

一个可重入的互斥锁 Lock，它具有与使用 synchronized 方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大（可以中断、定时）。

API文档上建议的用法：

建议总是 立即实践，使用 lock 块来调用 try，在之前/之后的构造中，最典型的代码如下： 

 class X {
   private final ReentrantLock lock = new ReentrantLock();
   // ...

   public void m() {
     lock.lock();  // block until condition holds
     try {
       // ... method body
     } finally {
       lock.unlock()
     }
   }
 }

应用示例：

import java.util.concurrent.locks.ReentrantLock;
// 账户类
class Account {
    private int accountBalance = 2000;
    private ReentrantLock lock = new ReentrantLock();
    public void withdraw(String userName, int amount) {
        synchronized (Account.class) {
            lock.lock();
            try {
                System.out.println(userName + "===in===");
                if (accountBalance >= amount) {
                    Thread.sleep(500);
                    accountBalance -= amount;// 取钱
                    System.out.println(userName + "取款" + amount + "，余额：" + accountBalance);
                } else {
                    System.out.println(userName + "企图取款" + amount + "，但余额只有：" + accountBalance);
                }
                System.out.println(userName + "===out===");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
}

练习：买票

(未做线程同步，请实现线程同步)

import java.util.Random;
public class 卖票 {
    public static void main(String[] args) {
        // 一个Runnable实例对象
        SellTicket st = new SellTicket();
        // 创建三个线程对象
        Thread t1 = new Thread(st, "窗口1");
        Thread t2 = new Thread(st, "窗口2");
        Thread t3 = new Thread(st, "窗口3");
        // 启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}
class SellTicket implements Runnable {
    // 定义票数
    private int tickets = 100;
    private void sell() {
        if (tickets > 0) {
            // 模拟售票过程
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            String name = Thread.currentThread().getName();
            System.out.println(name + "正在出售第" + (tickets--) + "张票");
        }
    }
    @Override
    public void run() {
        while (tickets > 0) {
            sell();
            // 模拟空闲过程
            try {
                Thread.sleep(new Random().nextInt(11) * 100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}