线程(四)---Lock

写在前面：各位看到此博客的小伙伴，如有不对的地方请及时通过私信我或者评论此博客的方式指出，以免误人子弟。多谢！  

提到 synchronized 不得不说一下Lock，它是从Java 5之后，在java.util.concurrent.locks包下的一个类，同synchronized一样都可以实现同步访问。两者的区别如下：

ReentranLock是Lock的唯一实现类，它可以实现公平锁，默认非公平，公平锁与非公平锁区别如下：

下面记录下ReentranLock的简单使用：

1.首先演示ReentranLock实现同步(与synchronized一样实现同步)的例子，

public class LockTest {

    static final ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) {
       
        LockTest test = new LockTest();
        new Thread(new Runnable() {
            @Override
            public void run() {
                test.test1();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                test.test1();
            }
        }).start();
    }


    public void test1(){
        try {
            lock.lock();
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " : " + i);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }


}

执行结果如下：

代码同上一篇测试synchronized的例子，结果也一样。

2.演示ReentranLock的公平锁与不公平锁

创建ReentranLock时传参数true创建的公平锁，传false或默认不传都为非公平锁

ReentranLock lock = new ReentranLock(true);

public class LockTest {

    // true: 公平锁
    static final ReentrantLock lock = new ReentrantLock(true);

    public static void main(String[] args) {

        for(int i=0;i<5;i++){
            new Thread(() -> test2()).start();
            // new Thread(() -> test1(),"B").start();
        }
    }


    static void test2(){
        for (int i = 0; i < 2; i++) {
            try {
                lock.lock();
                System.out.println(Thread.currentThread().getName() + "获取锁");
                TimeUnit.MILLISECONDS.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }
    }


}

公平锁执行结果如下(图一)：

改为非公平锁执行结果如下(图二)：

在这里启动5个线程，然后再test2方法中循环执行了两次加锁和解锁的过程(可重入)，发现两次打印顺序一致，即谁等的时间最长，谁就先获取锁；非公平锁的执行结果顺序是随机的，谁运气好，cpu时间片轮到哪个线程，哪个线程就能获取锁先执行。

补充：

tryLock(): 尝试获取锁，获取到返回true，获取不到返回false.

tryLock(long timeout, TimeUnit unit): 一个线程在指定的时间内没有获取锁，那就会返回false，就可以再去做其他事了。