多线程：ReentrantLock 到底是什么鬼

ReentrantLock 就是一个手动的锁

多线程左看右看的时候，发现了这么个东西。一开始只知道synchronized，后来知道了这个才觉得真心好用。
贴代码。

主要是看到有个帖子上的一道面试题，两个线程实现12A34B…这种
思路也是溜达溜达找到的，大体就是两个线程一个跑数字一个跑字母，交替跑实现。
ReentrantLock这个锁，默认非公平，当然你初始化的时候可以初始化公平锁。下面true就是公平锁。
公平锁是这么个意思：我用了锁，用完了后，我解锁了，我不会优先让我自己去用这个锁了，先给等的一个最优的人用。我再等机会用这个锁，你来我往大家和和气气的。
非公平就是：cpu你扫啊扫啊。时间片不给我我就用不到了哎。
当然，上面的“我” 就是个线程。

ReentrantLock 这个锁，你锁了就要开，你锁几层，你开几层。自己生产自己干完。
我用IDEA 线程断点(同事教会的，会的太少啊)，单步线程，这个单步调试过程中，我可以单步每一个我断点的线程，而我的角色就是cpu，我分的时间片，所以自己断点不存在cpu的随机，前提是你都断到了。所以，代码撸过去想看就看，先给自己mark一下。

public class TestThread {
private static String[] zimu = {“A”, “B”, “C”, “D”,”E”,”F”};
public static int count = 1;
public static int zimuNe = 0;
public static int shu = 1;
private static Lock lock = new ReentrantLock(true);

public static void main(String[] args) throws InterruptedException {
    PriZimu priZimu= new PriZimu();
    PriShuzi priShuzi = new PriShuzi();
    priZimu.start();
    priShuzi.start();
}

static class PriZimu extends Thread {
    @Override
    public void run() {
            for(int i = 0;i<8;){
                lock.lock();
                System.out.print("$");
                while (count%3!=0){
                    System.out.print(shu);
                    count++;
                    shu++;
                    i++;
                }
                lock.unlock();
            }
    }
}

static class PriShuzi extends Thread {
    @Override
    public void run() {
            for(int i = 0;i<8;){
                lock.lock();
                System.out.print("&");
                while (count%3==0){
                    System.out.print(zimu[zimuNe]);
                    zimuNe++;
                    count++;
                    i++;
                }
                lock.unlock();
            }
    }
}