Lock以及synchronized锁

class Phone{
    public static synchronized  void sendEmail() throws Exception{
        Thread.sleep(4000);
        System.out.println("-------------sendEmail");
    }
    public  synchronized  void sendSMS() throws Exception{
        System.out.println("-------------sendSMS");
    }

    public void hello(){
        System.out.println("hello");
    }
}

synchronized锁一般作用与防止多个线程共享资源类里的变量而用的锁。

*多线程8锁
1 标准访问，请问先打印邮件还是短信？邮件
2.邮件方法暂停4秒钟，请问先打印邮件还是短信？邮件
3.新增一个普通方法hello() ，请问先打印邮件还是hello？hello（普通方法）
4.两部手机，请问先打印邮件还是短信？短信（两部手机，则锁不同，分别位两个实现类的锁）
5.两个静态同步方法，统一部手机，请问先打印邮件还是短信？邮件（静态类，则锁作用在类上，无论几个手机都是先邮件）
6.两个静态同步方法，两部手机，请问先打印邮件还是短信？邮件（同上）
7.一个普通同步方法，一个静态同步方法，1部手机，请问先打印邮件还是短信？（短信，普通同步方法不抢静态类的锁）
8.一个普通同步方法，一个静态同步方法，2部手机，请问先打印邮件还是短信？短信 *

以上是根据以上资源类，同时用两个线程进行操作资源类中的函数，其中发邮件沉睡4s，看发短信是会等待4s后再进行还是直接进行。

首先创建两个手机

Phone phone = new Phone();
Phone phone2 = new Phone();

然后创建两个线程分别执行资源类中的方法，其中一个沉睡四秒

new Thread(() -> {
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();
        Thread.sleep(100);

        new Thread(() -> {
            try {
                //phone.sendSMS();
//                phone.hello();
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"B").start();

Lock锁

Lock锁的创建

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

与synchronized的对比

Lock

public void increase() throws InterruptedException{
    lock.lock();
    try{
        while (number!=0){
        condition.await();
    }
    number++;
    System.out.println(Thread.currentThread().getName()+"\t"+number);
    condition.signalAll();
    }catch (Exception e){
        e.printStackTrace();
    }finally{
        lock.unlock();
    }
}

synchronized

public synchronized void  increase() throws InterruptedException {
    while (number!=0){
        this.wait();
    }
    number++;
    System.out.println(Thread.currentThread().getName()+"\t"+number);
    this.notifyAll();
}

synchronized由lock.lock(),lock.unlock()代替
this.wait() 变为 condition.await(),this.notifyAll() 变为 conditon.signalAll()

notifyAll()以及signalAll()为唤醒所有线程