lock（重点）--Condition精准唤醒

Synchronized和lock的区别

Synchronized和lock的区别

1、Synchronized 内置的Java关键字，Lock是一个Java类
2、Synchronized 无法判断获取锁的状态，Lock 可以判断是否获取到了锁
3、Synchronized 会自动释放锁，lock必须要手动释放锁!如果不释放锁，死锁
4、Synchronized 线程1(获得锁，阻塞)、线程2(等待，傻傻的等） ; Lock锁就不一定会等待下去;
5、Synchronized可重入锁，不可以中断的，非公平;Lock，可重入锁，可以判断锁，非公平(可以自己设置）;
6、Synchronized适合锁少量的代码同步问题，Lock 适合锁大量的同步代码!

>lock 接口

• ReentrantLock 可重入锁
• ReadLock 读锁
• WriterLock 写锁

lock的使用

//1,new ReentrantLock()
//2,lock.lock();加锁
//3,lock.unlock();解锁

package Lock;

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

/**
 * lock--Condition     取代了对象监视器方法的使用
 *
 * @author liu
 */
public class Demo03 {
    public static void main(String[] args) {
        Data1 data = new Data1();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "C").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "D").start();
    }
}

class Data1 {
    private int number = 0;
    //lock--Condition,代替监听，
    //condition.await();等待
    //condition.signalAll();唤醒
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    //+1
    public void increment() throws InterruptedException {
        lock.lock();
        //0工作,如果用if判断，会造成虚假唤醒
        try {
            while (number != 0) {
                //等待
                condition.await();
            }
            number++;
            //通知其他线程，我+1完毕了
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

    //-1
    public void decrement() throws InterruptedException {
        lock.lock();
        try {
            // 1工作
            while (number == 0) {
                //等待
                condition.await();
            }
            number--;
            //通知其他线程，我-1完毕了
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

Condition精准唤醒

package Lock;


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

/**condition 精准唤醒
 * @author liu
 */
public class ConditionClass {
    public static void main(String[] args) {
        data3 data3 = new data3();
        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                data3.printA();
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                data3.printB();
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                data3.printC();
            }
        }, "C").start();

    }
}


class data3 {
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    // 这里是condition类型，不是lock类型，而且这个condition类型和ConditionClass类型不一样，刚刚重名了
    private Condition condition3 = lock.newCondition();

    private int num = 1;//1A-2B-3C-1A

    public void printA() {
        lock.lock();
        try {//判断，业务，执行，通知
            while (num != 1) {
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName() + "==>AAAAAA");
            this.num = 2;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printB() {
        lock.lock();
        try {//判断，业务，执行，通知
            while (num != 2) {
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName() + "==>BBBB");
            this.num = 3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printC() {
        lock.lock();
        try {//判断，业务，执行，通知
            while (num != 3) {
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName() + "==>CCCCC");
            this.num = 1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}