synchronized (mutex) {//mutex 称为同步锁，也叫互斥锁。
// 原子性操作
}

package day16_thread.classing.thicks;
/**
 * @author Xiao_Lin
 * @date 2020/12/20 14:15
 */
public class MyRun implements Runnable {
  private int count = 500;
  @Override
  public void run() {
    for (int i=0;i<1000;i++){
     synchronized (this){
       if (count>20){
         count--;
         System.out.println(Thread.currentThread().getName()+"卖了一张票。还剩下"+count+"张票");
       }
     }
    }
  }
}

package day16_thread.classing.thicks;
/**
 * @author Xiao_Lin
 * @date 2020/12/20 14:17
 */
public class TestRun {
  public static void main(String[] args) {
    MyRun myRun = new MyRun();
    Thread t1 = new Thread(myRun,"窗口A");
    Thread t2 = new Thread(myRun,"窗口B");
    Thread t3 = new Thread(myRun,"窗口C");
    Thread t4 = new Thread(myRun,"窗口D");
    t1.start();
    t2.start();
    t3.start();
    t4.start();
  }
}

修饰符 synchronized 返回值类型 方法名称(){
    //原子性操作
}

public class Ticket implements Runnable{
  private int ticket = 100;
  //创建锁对象
  Lock lock = new ReentrantLock();
  /*
   * 执行卖票操作
   */
  @Override
  public void run() {
    //每个窗口卖票的操作 
    //窗口 永远开启 
    while(true){
      lock.lock();//上锁操作
      if(ticket>0){//有票 可以卖
        //出票操作 
        //使用sleep模拟一下出票时间 
        try {
          Thread.sleep(50);
        } catch (InterruptedException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
        }
        //获取当前线程对象的名字 
        String name = Thread.currentThread().getName();
        System.out.println(name+"正在卖:"+ticket--);
      }
      lock.unlock();//解锁操作
    }
  }
}

package com;
// 账户对象
public class Account {
    private String cardId ;
    private double money ; // 余额。
    public Account() {
    }
    public Account(String cardId, double money) {
        this.cardId = cardId;
        this.money = money;
    }
    // 亲爸，干爹，岳父
    public synchronized void saveMoney(double money) {
        try{
            // 1.知道是谁来存钱
            String name = Thread.currentThread().getName();
            // 2.判断余额是否足够
            if(this.money > 0){
                // 5.等待自己，唤醒别人！
                this.notifyAll();
                this.wait();
            }else{
                // 3.钱没有，存钱
                this.money += money;
                System.out.println(name+"来存钱，存入了"+money+"剩余："+this.money);
                // 4.等待自己，唤醒别人！
                this.notifyAll();
                this.wait();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    // 小明 小红
    public synchronized void drawMoney(double money) {
        try{
            // 1.知道是谁来取钱
            String name = Thread.currentThread().getName();
            // 2.判断余额是否足够
            if(this.money > 0){
                // 3.账户有钱，有钱可以取
                this.money -= money;
                System.out.println(name+"来取钱"+money+"取钱后剩余："+this.money);
                // 4.没钱，先唤醒别人，等待自己，。
                this.notifyAll();
                this.wait();
            }else{
                // 5.余额不足，没钱，先唤醒别人，等待自己，。
                this.notifyAll();
                this.wait();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    public String getCardId() {
        return cardId;
    }
    public void setCardId(String cardId) {
        this.cardId = cardId;
    }
    public double getMoney() {
        return money;
    }
    public void setMoney(double money) {
        this.money = money;
    }
}

package com;
/**
    取钱的线程类
 */
public class DrawThread extends Thread {
    private Account acc ; // 定义了一个账户类型的成员变量接收取款的账户对象！
    public DrawThread(Account acc , String name){
        super(name); // 为当前线程对象取名字
        this.acc = acc ;
    }
    @Override
    public void run() {
        while(true){
            try {
                Thread.sleep(4000);
                acc.drawMoney(10000);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

package com;
/**
    存钱的线程类
 */
public class SaveThread extends Thread {
    private Account acc ; // 定义了一个账户类型的成员变量接收取款的账户对象！
    public SaveThread(Account acc , String name){
        super(name); // 为当前线程对象取名字
        this.acc = acc ;
    }
    @Override
    public void run() {
        while(true){
            try {
                Thread.sleep(4000);
                acc.saveMoney(10000);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

package com;
/**
    目标：线程通信（了解原理，代码几乎不用）
    线程通信：多个线程因为在同一个进程中，所以互相通信比较容易的。
    线程通信的经典模型：生产者与消费者问题。
         生产者负责生成商品，消费者负责消费商品。
         生产不能过剩，消费不能没有。
    模拟一个案例：
        小明和小红有一个共同账户：共享资源
        他们有3个爸爸（亲爸，岳父，干爹）给他们存钱。
        模型：小明和小红去取钱，如果有钱就取出，然后等待自己，唤醒他们3个爸爸们来存钱
             他们的爸爸们来存钱，如果发现有钱就不存，没钱就存钱，然后等待自己，唤醒孩子们来取钱。
             做整存整取：10000元。
    分析：
        生产者线程：亲爸，岳父，干爹
        消费者线程：小明，小红
        共享资源：账户对象。
    注意：线程通信一定是多个线程在操作同一个资源才需要进行通信。
         线程通信必须先保证线程安全，否则毫无意义，代码也会报错！
    线程通信的核心方法：
        public void wait(): 让当前线程进入到等待状态 此方法必须锁对象调用.
        public void notify() : 唤醒当前锁对象上等待状态的某个线程  此方法必须锁对象调用
        public void notifyAll() : 唤醒当前锁对象上等待状态的全部线程  此方法必须锁对象调用
    小结：
        是一种等待唤醒机制。
        必须是在同一个共享资源才需要通信，而且必须保证线程安全。
  */
public class ThreadCommunication {
    public static void main(String[] args) {
        // 1.创建一个账户对象。
        Account acc = new Account("ICBC-1313113",0);
        // 2.创建2个取钱线程。
        new DrawThread(acc , "小明").start();
        new DrawThread(acc , "小红").start();
        // 3.创建3个存钱线程。
        new SaveThread(acc , "亲爹").start();
        new SaveThread(acc , "干爹").start();
        new SaveThread(acc , "岳父").start();
    }
}

public class VolatileThread extends Thread {
    // 定义成员变量
    private boolean flag = false ;
    public boolean isFlag() { return flag;}
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 将flag的值更改为true
        this.flag = true ;
        System.out.println("flag=" + flag);
    }
}
public class VolatileThreadDemo {// 测试类
    public static void main(String[] args) {
        // 创建VolatileThread线程对象
        VolatileThread volatileThread = new VolatileThread() ;
        volatileThread.start();
        // main方法
        while(true) {
            if(volatileThread.isFlag()) {
                System.out.println("执行了======");
            }
        }
    }
}

while(true){
    synchronized(t){
        if(t.isFlag()){
            System.out.print("主线程进入循环")
        }
    }
}

public class VolatileAtomicThread implements Runnable {
    // 定义一个int类型的遍历
    private int count = 0 ;
    @Override
    public void run() {
        // 对该变量进行++操作，100次
        for(int x = 0 ; x < 100 ; x++) {
            count++ ;         
            System.out.println("count =========>>>> " + count);
        }
    }
}
public class VolatileAtomicThreadDemo {
    public static void main(String[] args) {
        // 创建VolatileAtomicThread对象
        VolatileAtomicThread volatileAtomicThread = new VolatileAtomicThread() ;
        // 开启100个线程对count进行++操作
        for(int x = 0 ; x < 100 ; x++) {
            new Thread(volatileAtomicThread).start();
        }
    }
}

public class VolatileAtomicThread implements Runnable {
    // 定义一个int类型的变量
    private volatile int count = 0 ;
    private static final Object obj = new Object();
    @Override
    public void run() {
        // 对该变量进行++操作，100次
        for(int x = 0 ; x < 100 ; x++) {
            synchronized (obj) {
                count++ ;
                System.out.println("count =========>>>> " + count);
            }
        }
    }
}

public class VolatileAtomicThread implements Runnable {
    // 定义一个int类型的变量,默认值是0，我们也可以指定长度
    private AtomicInteger atomicInteger = new AtomicInteger() ;
    @Override
    public void run() {
        // 对该变量进行++操作，100次
        for(int x = 0 ; x < 100 ; x++) {
            int i = atomicInteger.getAndIncrement();
            System.out.println("count =========>>>> " + i);
        }
    }
}