回顾多线程

1.线程有几种状态

 public enum State {
      //新生
        NEW,

       //运行
        RUNNABLE,

      //阻塞
        BLOCKED,

      //等待
        WAITING,

       //超时等待
        TIMED_WAITING,

      //终止
        TERMINATED;
    }

2.wait和sleep的区别

1.来自不同的类

wait=>Object类   

sleep => Thread类

2.关于锁的释放

wait 会释放锁，

sleep 睡觉了，抱着锁睡觉，不会释放！

3.使用的范围是不同的

wait  必须在同步代码块中使用

sleep 可以在任何地方睡

4.是否可以需要捕获异常   都是中断异常

wait 需要捕获异常

sleep 也需要抛出异常

3.Lock锁（重点）

1.传统Synchronized

package com.kuang.lock;
//基本的卖票例子

/**
 * 真正的多线程开发,公司中的开发,降低耦合性
 * 线程就是一个单独的资源类，他没有任何附属的操作！
 * 1.属性 、方法
 */
public class SaleTicketDemo01 {
       public static void main(String[] args) {
           //并发：多线程操作同一个资源类，把资源类丢入线程。
           Ticket ticket = new Ticket();
           //@FunctionalInterface 函数式接口 ,jdk1.8 Lambda表达式 (参数) -> {代码}
            new Thread(()->{
                for (int i = 0; i < 60; i++) {
                     ticket.sale();
                }
            },"A").start();
            new Thread(()->{
                for (int i = 0; i < 60; i++) {
                    ticket.sale();
                }
            },"B").start();
            new Thread(()->{
                for (int i = 0; i < 60; i++) {
                    ticket.sale();
                }
            },"C").start();




       }



}

// 资源类 OOP
class Ticket{
   // 属性、方法
    private int number=50;
    //卖票的方式
    public synchronized void sale(){
        if (number>0){
            System.out.println(Thread.currentThread().getName()+"：卖出第"+(number--)+"张票,还剩"+number+"张票");
        }
    }


}

2.lock接口

new FairSync()公平锁

new NonfairSync()非公平锁

公平锁：十分公平，可以先来后到

非公平锁：十分不公平，可以插队(默认)

3秒 和 3小时的 如果公平锁 3秒中必须等3小时之后才能执行，

但是插队的话，就是谁抢到，谁执行，而且是有锁的。

package com.kuang.lock;

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

public class SaleTicketDemo02 {
    public static void main(String[] args) {
        //并发：多线程操作同一个资源类，把资源类丢入线程。
        Ticket2 ticket = new Ticket2();
        new Thread(()->{for (int i = 0; i < 60; i++) ticket.sale();},"A").start();
        new Thread(()->{for (int i = 0; i < 60; i++) ticket.sale();},"B").start();
        new Thread(()->{for (int i = 0; i < 60; i++) ticket.sale();},"C").start();
    }
}

// 资源类 OOP
class Ticket2 {
    // 属性、方法
    private int number = 50;

    //卖票的方式
    //lock
    Lock lock =new ReentrantLock();


    public void sale() {

        lock.lock();//加锁

        try {
            //业务代码
            if (number > 0) {
                System.out.println(Thread.currentThread().getName() + "：卖出第" + (number--) + "张票,还剩" + number + "张票");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();//解锁
        }
    }
}

3.Synchronized 和 Lock 区别

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

提问？：锁是什么？如何判断锁的是谁！