JUC-第六篇 : JUC线程重入锁Lock

最新推荐文章于 2022-11-03 17:55:12 发布

程序员果果

最新推荐文章于 2022-11-03 17:55:12 发布

阅读量141

点赞数 1

本文链接：https://blog.csdn.net/u010562966/article/details/102976385

版权

一、简介

重入锁可以完全代替synchronized关键字，在JDK5.0 的早期版本，重入锁的性能远远好于synchronized，但从JDK1.6开始，JDK 在 synchronized 上做了大量的优化，使得两者的性能差距不大。官方甚至推荐在仅用于互斥代码时使用synchronize锁。

实例

1.问题

package com.gf.demo;

public class TestLock {

    public static void main(String args[]) {
        Ticket ticket = new Ticket();
        for (int i = 0; i < 3; i++) {
            new Thread( ticket, i + 1 + "号窗口" ).start();
        }
    }
}

class Ticket implements Runnable {

    private int tick = 100;

    @Override
    public void run() {

        while (true) {
            if (0 < tick) {
                try {
                    Thread.sleep( 1000 );
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println( Thread.currentThread().getName() + " 完成售票，余票为：" + --tick );
            }
        }

    }
}

上面的售票问题，运行你会发现存在线程安全问题，下面是解决方案。

2、解决方案

1. synchronized

synchronized:隐式锁
- 同步代码块
- 同步方法

class Ticket implements Runnable {

    private int tick = 100;

    @Override
    public void run() {

        while (true) {
            synchronized (Ticket.class) {
                if (0 < tick) {
                    try {
                        Thread.sleep( 200 );
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println( Thread.currentThread().getName() + " 完成售票，余票为：" + --tick );
                }
            }
        }

    }
}

2. 同步锁Lock

1.5之后我们可以有另一中方式：

同步锁Lock（注意：是一个显示锁，需要通过lock() 方法上锁，必须通过unlock() 方法释放锁）

class Ticket implements Runnable {

    private int tick = 100;

    //解决方案
    private Lock lock = new ReentrantLock();

    @Override
    public void run() {

        while (true) {
            try {
                lock.lock();
                if (0 < tick) {
                    try {
                        Thread.sleep( 200 );
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println( Thread.currentThread().getName() + " 完成售票，余票为：" + --tick );
                }
            } finally {
                lock.unlock();
            }
        }

    }
}

何时加锁，何时释放锁，一目了然，也正是因为这样，重入锁对逻辑控制的灵活性要远好于synchronized。但值得注意的是，必须记得释放锁。

有些人对重入锁的名字感到奇怪。锁就是锁呗，为什么要加上 “重入” 两个字呢？从类的命名上来看，Re-Entrant-Lock 翻译成重入锁也是非常贴切的。当然，这里的反复仅仅局限于一个线程。如下：

lock.lock();
lock.lock();
try {
     i++
} finally {
     lock.unlock();
     lock.unlock();
}

在这中情况下，一个线程连续两次获得同一把锁。这是允许的！但是值得注意的是，前期申请几次锁，之后就要释放相同次数，如果释放的少了，相当于线程还是持有这个锁，其他线程也就无法进入临界区。

3. 中断响应

使用 synchronized 时，如果一个线程在等待锁，结果就是它获得锁，或者是它继续等待，这两种情况，但是使用重入锁就是多了一种可能，就是在等待锁的时候，终断对这把锁的请求。

package com.gf.demo;

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

public class TestLockInterrupt {

    public static void main(String[] args) {
        LockInterruptDemo ld = new LockInterruptDemo();
        Thread t1 = new Thread( ld, "线程A" );
        Thread t2 = new Thread( ld  , "线程B" );
        t1.start();
        t2.start();
        t2.interrupt();

    }
}

class LockInterruptDemo implements Runnable {

    private  Lock lock = new ReentrantLock();

    @Override
    public void run() {
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + " running");
            TimeUnit.SECONDS.sleep(5);
            System.out.println(Thread.currentThread().getName() + " finished");
        } catch(InterruptedException e) {
            System.out.println(Thread.currentThread().getName() + " interrupted");
        } finally {
            lock.unlock();
        }
    }
}

运行结果:

线程A running
线程A finished
线程B running
线程B interrupted

当 lock.lock() 改为 lock.lockInterruptibly() 时执行结果如下：

Exception in thread "线程B" java.lang.IllegalMonitorStateException
线程B interrupted
    at java.util.concurrent.locks.ReentrantLock$Sync.tryRelease(ReentrantLock.java:151)
线程A running
    at java.util.concurrent.locks.AbstractQueuedSynchronizer.release(AbstractQueuedSynchronizer.java:1261)
    at java.util.concurrent.locks.ReentrantLock.unlock(ReentrantLock.java:457)
    at com.gf.demo.LockInterruptDemo.run(TestLockInterrupt.java:34)
    at java.lang.Thread.run(Thread.java:745)
线程A finished

所有得出以下两点结论：

使用 lockInterruptibly() 需要记住：当前线程可以被其他线程中止，并且在其他线程中抛出异常信息；
使用 lock() 需要记住：当前线程也可以被其他线程中止，但不会抛出异常信息；

4. 锁申请等待限时

package com.gf.demo;

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

public class TimeLockTry implements Runnable{

    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        try {
            try {
                if (lock.tryLock( 5 , TimeUnit.SECONDS )) {
                    System.out.println(Thread.currentThread().getName() + "获得锁");
                    Thread.sleep( 10000 );
                } else {
                    System.out.println(Thread.currentThread().getName() + "尝试了5秒，没有获得锁");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }

    }

    public static void main(String args[]){
        TimeLockTry ty = new TimeLockTry();

        Thread t1 = new Thread( ty  , "线程A");
        Thread t2 = new Thread( ty  , "线程B");

        t1.start();
        t2.start();

    }
}

tryLock() 有两个参数，一个是等待时长，一个是时间单位。等待时间内获取到锁返回 true ，否则返回false

5. 公平锁

一般来说，申请锁都不是公平的，没有时间顺序，系统只是会从这个锁等待队列中随机挑选一个，因此不能保证是公平的，很像不排队买票的窗口。对于公平锁，它会按照时间顺序，保证先到的先申请资源，对于 sycnronized 关键字申请锁，它是非公平的。但是重入锁，我们可以对公平性进行设置 ReentrantLock 它有一个构造方法：

public ReentrantLock(boolean fair)

参数 fair 为 true 时，表示是公平锁，因为公平锁内部维护了一个队列，因此在公平锁的性能并不好，所以没有特殊要求，一般不使用公平锁。下面是公平锁的实例：

package com.gf.demo;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.ReentrantLock;

public class TestLockFair {

    public static void main(String args[]) throws InterruptedException {
        LockFairDemo ld = new LockFairDemo();

        List<Thread> list = new ArrayList<>();
        for (int i = 1 ; i<= 100 ; i++) {
            Thread thread = new Thread( new Runnable() {
                @Override
                public void run() {
                    ld.print();
                }
            }, "线程" + i );
            list.add( thread );
        }

        for (Thread t : list) {
            t.start();
        }

    }
}

class LockFairDemo {

    private ReentrantLock lock = new ReentrantLock(true);

    public void print() {
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName());
        } finally {
            lock.unlock();
        }
    }
}