锁相关知识

前言

一、锁的类型

自旋锁如上图

可重入锁 和 不可重入锁：

可重入锁：可重入就是说A线程已经获得某个锁，B线程在后面发现有锁，直接使用锁，枷锁几次必须释放几次。
不可重入锁 ：A线程已经获得某个锁，b也想使用该锁的话，必须等到A锁释放，否则会出现死锁

公平锁 和 非公平锁

公平锁：A->B->C->D->E 当E释放锁，就该D拿到锁，
费公平锁：A->B->C->D->E 当E释放锁，A.B.C.D同时去拿，指不定谁重新拿到

读写锁

读锁又叫共享锁
写锁又叫排他锁（互斥锁）
读 + 读 相当于无锁，并发读，同时加锁成功
写 + 写 阻塞状态
写 + 读 等待写锁释放
读 + 写 等待读锁完，才写，

买票例子：

public class TicketTest {

    @Test
    public void test() {
         Ticket ticket = new Ticket();
        new Thread(() -> { for (int i = 1; i <= 40; i++)ticket.sale(); }, "A").start();
        new Thread(() -> { for (int i = 1; i <= 40; i++)ticket.sale(); }, "B").start();
        new Thread(() -> { for (int i = 1; i <= 40; i++)ticket.sale(); }, "C").start();
    }

    class Ticket {
        protected int number = 40;
        public synchronized void sale() {
                if (number > 0) {
                    System.out.println(Thread.currentThread().getName() + "线程卖出第" + number-- + "张票；还剩：" + number + "张。");
                }
        }
    }
}

二、 synchronized

 class Ticket {
        protected int number = 40;
        public synchronized void sale() {
            if (number > 0) {
                System.out.println(Thread.currentThread().getName() + "线程卖出第" + number-- + "张票；还剩：" + number + "张。");
            }
        }
    }

    class Ticket {
        protected int number = 40;
        public  void sale() {
            synchronized(this){
                if (number > 0) {
                    System.out.println(Thread.currentThread().getName() + "线程卖出第" + number-- + "张票；还剩：" + number + "张。");
                }
            }
        }
    }

    class Ticket {
        public final Map map = new HashMap();
        protected int number = 40;
        public void sale() {
            synchronized (map) {
                if (number > 0) {
                    System.out.println(Thread.currentThread().getName() + "线程卖出第" + number-- + "张票；还剩：" + number + "张。");
                }
            }
        }
    }

静态类:

 static class Ticket {
        protected int number = 40;
        public void sale() {
            synchronized (Ticket.class) {
                if (number > 0) {
                    System.out.println(Thread.currentThread().getName() + "线程卖出第" + number-- + "张票；还剩：" + number + "张。");
                }
            }
        }
    }

三、Lock

（一）常用方法

（二）实现子类

源码：

  public ReentrantLock() {
  //默认非公平锁
            sync = new ReentrantLock.NonfairSync();
        }
  public ReentrantLock(boolean fair) {
  //  如果true 此锁应使用公平排序策略
            sync = fair ? new ReentrantLock.FairSync() : new ReentrantLock.NonfairSync();
        }

四、synchronized 与 Lock 区别

1、synchronized 是java 关键字 Lock 是java类
2、synchronized 无法获取锁的状态，Lock 是可以判断是否获取锁
3、synchronized 自动释放锁、Lock 必须手动释放锁
4、synchronized 线程1(获取锁，阻塞/等待) 线程2（只能等待）， Lock 不会
5、synchronized 可从入锁，不可中断，非公平。Lock 可从入锁，可以判断，非公平锁(可设置)
6、synchronized 适合锁少量的代码块儿，Lock 适合锁大量同步代码。

S SDS
Lock 等待，通知方法

五、辅助类CountDownLatch Semaphore

@org.junit.Test
    public void test12() throws InterruptedException {
         //CountDownLatch 减法计数器
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 0; i < 6; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + " go out");
                countDownLatch.countDown(); //-1
            }, String.valueOf(i)).start();
        }
        //等待计数器归0再向下执行
        countDownLatch.await();
        System.out.println("close door");
    }

总结

提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。