1、Lock锁

Synchronized和Lock的区别：参考

1、synchronized是内置关键字，Lock是一个类（接口）
2、synchronized无法判断获取锁的状态，Lock可以判断是否获取到了锁
3、synchronized会自动释放锁，lock必须要手动释放，（如果不释放，会形成死锁）
4、synchronized中线程1如果获得锁，线程2就会一直等待，直到线程1释放；lock锁就不会，tryLcok();
5、synchronized可重入锁，不可以中断，非公平锁；Lock锁可重入锁，可以判断锁，默认非公平（可以设置）
6、适合锁少量的代码同步问题；lock适合锁大量的同步代码（灵活度高）

锁是什么？如何判断锁的是谁？

synchronized锁的对象是方法的调用者！（对象）
如果是静态同步方法，则锁的是Class（类）

2、生产者和消费者问题

生产者和消费者问题（线程通信）(使用synchronized、wait()、notifyAll())
拓展问题:java中的notify和notifyAll有什么区别

package com.company.ThreadTest;

/**
 * 线程之间的通信问腿：生产者和消费者
 * 线程交替执行 A  B 操作同一个变量  num=0
 * A num+1
 * B num-1
 */
public class TestProductorAndConsumer {

    public static void main(String[] args) {

        Data data = new Data();

        //A线程
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

        //B线程
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
    }
}

/**
 * 1、判断等待
 * 2、业务
 * 3、通知
 */
class Data{ //资源类

    private int number = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
        //判断等待
        if (number!=0){
            //等待
            this.wait();
        }
        //业务
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知B线程可以消费了，我+1完毕
        this.notifyAll();

    }
    //+1
    public synchronized void decrement() throws InterruptedException {
        //判断等待
        if (number==0){
            //等待
            this.wait();
        }
        //业务
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知A线程可以生产了，我-1完毕
        this.notifyAll();

    }

}

结果：

A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0

问题：上述示例如果存在ABCD四个线程！结果可能出现如下：（虚假唤醒）

什么是虚假唤醒：当一个条件满足时，很多线程都被唤醒了，但是只有其中部分是有用的唤醒，其它的唤醒都是无用功。比如说买货，如果商品本来没有货物，突然进了一件商品，这是所有的线程都被唤醒了，但是只能一个人买，所以其他人都是假唤醒，获取不到对象的锁

package com.company.ThreadTest;

/**
 * 线程之间的通信问腿：生产者和消费者
 * 线程交替执行 A  B 操作同一个变量  num=0
 * A num+1
 * B num-1
 */
public class TestProductorAndConsumer {

    public static void main(String[] args) {

        Data data = new Data();

        //A线程
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

        //B线程
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();

        //C线程
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();

        //D线程
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}

/**
 * 1、判断等待
 * 2、业务
 * 3、通知
 */
class Data{ //资源类

    private int number = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
        //判断等待
        if (number!=0){
            //等待
            this.wait();
        }
        //业务
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知B线程可以消费了，我+1完毕
        this.notifyAll();

    }
    //+1
    public synchronized void decrement() throws InterruptedException {
        //判断等待
        if (number==0){
            //等待
            this.wait();
        }
        //业务
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知A线程可以生产了，我-1完毕
        this.notifyAll();

    }

}

A=>1
B=>0
C=>1
A=>2
C=>3
B=>2
B=>1
B=>0
C=>1
A=>2
C=>3
B=>2
C=>3
D=>2
D=>1
D=>0
A=>1
D=>0
A=>1
D=>0

虚假唤醒的解决办法：

只需将if (number!=0){} 换成while(number!=0){}

因为if只会执行一次，执行完会接着向下执行if（）外边的;而while不会，直到条件满足才会向下执行while（）外边的

JUC版的生产者和消费者问题：

JUC版的用法：

1605515573(1).png
1605515700(1).jpg

package com.company.ThreadTest;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 线程之间的通信问腿：生产者和消费者
 * 线程交替执行 A  B 操作同一个变量  num=0
 * A num+1
 * B num-1
 */
public class TestJUCProductorAndConsumer {

    public static void main(String[] args) {

        Data2 data = new Data2();

        //A线程
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

        //B线程
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();

        //C线程
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();

        //D线程
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}

/**
 * 1、判断等待
 * 2、业务
 * 3、通知
 */
class Data2{ //资源类

    private int number = 0;

    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    //condition.await();//等待
    //condition.signalAll();//唤醒全部

    //+1
    public void increment() throws InterruptedException {
        lock.lock();//上锁
        try {
            //业务代码
            //判断等待
            while (number!=0){
                //等待
                condition.await();
            }
            //业务
            number++;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            //通知B线程可以消费了，我+1完毕
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock(); //释放锁
        }


    }
    //+1
    public void decrement() throws InterruptedException {
        lock.lock();//上锁
        try {
            //判断等待
            while (number==0){
                //等待
                condition.await();
            }
            //业务
            number--;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            //通知A线程可以生产了，我-1完毕
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();//释放锁
        }


    }

}

结果：

A=>1
B=>0
C=>1
B=>0
C=>1
B=>0
C=>1
B=>0
C=>1
B=>0
C=>1
D=>0
A=>1
D=>0
A=>1
D=>0
A=>1
D=>0
A=>1
D=>0

思考：上述结果为随机状态，如何让ABCD变得有序

Condition(按ABC的顺序打印)

package com.company.ThreadTest;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 线程之间的通信问腿：生产者和消费者
 * 线程交替执行 A  B 操作同一个变量  num=0
 * A num+1
 * B num-1
 */
public class TestJUCProductorAndConsumer2 {

    public static void main(String[] args) {

        Data3 data = new Data3();

        //A线程
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                data.printA();
            }
        },"A").start();

        //B线程
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                data.printB();
            }
        },"B").start();

        //C线程
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                data.printC();
            }
        },"C").start();

    }
}

/**
 * 1、判断等待
 * 2、业务
 * 3、通知
 */
class Data3{ //资源类

    private int number = 1;

    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();


    public void printA(){
        lock.lock();
        try {
            while (number!=1){
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"-->AAAAA");
            number = 2;
            //唤醒指定的人B
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printB(){
        lock.lock();
        try {
            while (number!=2){
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+"-->BBBBB");
            number = 3;
            //唤醒指定的人C
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printC(){
        lock.lock();
        try {
            while (number!=3){
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+"-->CCCCC");
            number = 1;
            //唤醒指定的人
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

结果：

A-->AAAAA
B-->BBBBB
C-->CCCCC
A-->AAAAA
B-->BBBBB
C-->CCCCC
A-->AAAAA
B-->BBBBB
C-->CCCCC
A-->AAAAA
B-->BBBBB
C-->CCCCC
A-->AAAAA
B-->BBBBB
C-->CCCCC