Java 中的锁通常分为两种:

  • 通过关键字 synchronized 获取的锁,我们称为同步锁,上一篇有介绍到:Java 多线程并发编程 Synchronized 关键字
  • java.util.concurrent(JUC)包里的锁,如通过继承接口 Lock 而实现的 ReentrantLock(互斥锁),继承 ReadWriteLock 实现的 ReentrantReadWriteLock(读写锁)。

本篇主要介绍 ReentrantLock(互斥锁)。

ReentrantLock(互斥锁)

ReentrantLock 互斥锁,在同一时间只能被一个线程所占有,在被持有后并未释放之前,其他线程若想获得该锁只能等待或放弃。

ReentrantLock 互斥锁是可重入锁,即某一线程可多次获得该锁。

公平锁 and 非公平锁

    public ReentrantLock() { 
        sync = new NonfairSync(); 
    } 
 
    public ReentrantLock(boolean fair) { 
        sync = fair ? new FairSync() : new NonfairSync(); 
    }

由 ReentrantLock 的构造函数可见,在实例化 ReentrantLock 的时候我们可以选择实例化一个公平锁或非公平锁,而默认会构造一个非公平锁。

公平锁与非公平锁区别在于竞争锁时的有序与否。公平锁可确保有序性(FIFO 队列),非公平锁不能确保有序性(即使也有 FIFO 队列)。

然而,公平是要付出代价的,公平锁比非公平锁要耗性能,所以在非必须确保公平的条件下,一般使用非公平锁可提高吞吐率。所以 ReentrantLock 默认的构造函数也是“不公平”的。

一般使用

DEMO1:

public class Test { 
 
    private static class Counter { 
 
        private ReentrantLock mReentrantLock = new ReentrantLock(); 
 
        public void count() { 
            mReentrantLock.lock(); 
            try { 
                for (int i = 0; i < 6; i++) { 
                    System.out.println(Thread.currentThread().getName() + ", i = " + i); 
                } 
            } finally { 
	            // 必须在 finally 释放锁 
                mReentrantLock.unlock(); 
            } 
        } 
    } 
 
    private static class MyThread extends Thread { 
 
        private Counter mCounter; 
 
        public MyThread(Counter counter) { 
            mCounter = counter; 
        } 
 
        @Override 
        public void run() { 
            super.run(); 
            mCounter.count(); 
        } 
    } 
 
    public static void main(String[] var0) { 
        Counter counter = new Counter(); 
        // 注:myThread1 和 myThread2 是调用同一个对象 counter 
        MyThread myThread1 = new MyThread(counter); 
        MyThread myThread2 = new MyThread(counter); 
        myThread1.start(); 
        myThread2.start(); 
    } 
}

DEMO1 输出:

Thread-0, i = 0 
Thread-0, i = 1 
Thread-0, i = 2 
Thread-0, i = 3 
Thread-0, i = 4 
Thread-0, i = 5 
Thread-1, i = 0 
Thread-1, i = 1 
Thread-1, i = 2 
Thread-1, i = 3 
Thread-1, i = 4 
Thread-1, i = 5

DEMO1 仅使用了 ReentrantLock 的 lock 和 unlock 来提现一般锁的特性,确保线程的有序执行。此种场景 synchronized 也适用。

锁的作用域

DEMO2:

public class Test { 
 
    private static class Counter { 
 
        private ReentrantLock mReentrantLock = new ReentrantLock(); 
 
        public void count() { 
            for (int i = 0; i < 6; i++) { 
                mReentrantLock.lock(); 
                // 模拟耗时,突出线程是否阻塞 
                try{ 
                    Thread.sleep(100); 
                    System.out.println(Thread.currentThread().getName() + ", i = " + i); 
                } catch (InterruptedException e) { 
                    e.printStackTrace(); 
                } finally { 
	                // 必须在 finally 释放锁 
                    mReentrantLock.unlock(); 
                } 
            } 
        } 
 
        public void doOtherThing(){ 
            for (int i = 0; i < 6; i++) { 
                // 模拟耗时,突出线程是否阻塞 
                try { 
                    Thread.sleep(100); 
                } catch (InterruptedException e) { 
                    e.printStackTrace(); 
                } 
                System.out.println(Thread.currentThread().getName() + " doOtherThing, i = " + i); 
            } 
        } 
    } 
 
    public static void main(String[] var0) { 
        final Counter counter = new Counter(); 
        new Thread(new Runnable() { 
            @Override 
            public void run() { 
                counter.count(); 
            } 
        }).start(); 
        new Thread(new Runnable() { 
            @Override 
            public void run() { 
                counter.doOtherThing(); 
            } 
        }).start(); 
    } 
}

DEMO2 输出:

Thread-0, i = 0 
Thread-1 doOtherThing, i = 0 
Thread-0, i = 1 
Thread-1 doOtherThing, i = 1 
Thread-0, i = 2 
Thread-1 doOtherThing, i = 2 
Thread-0, i = 3 
Thread-1 doOtherThing, i = 3 
Thread-0, i = 4 
Thread-1 doOtherThing, i = 4 
Thread-0, i = 5 
Thread-1 doOtherThing, i = 5

DEMO3:

public class Test { 
 
    private static class Counter { 
 
        private ReentrantLock mReentrantLock = new ReentrantLock(); 
 
        public void count() { 
            for (int i = 0; i < 6; i++) { 
                mReentrantLock.lock(); 
                // 模拟耗时,突出线程是否阻塞 
                try{ 
                    Thread.sleep(100); 
                    System.out.println(Thread.currentThread().getName() + ", i = " + i); 
                } catch (InterruptedException e) { 
                    e.printStackTrace(); 
                } finally { 
                    // 必须在 finally 释放锁 
                    mReentrantLock.unlock(); 
                } 
            } 
        } 
 
        public void doOtherThing(){ 
            mReentrantLock.lock(); 
            try{ 
                for (int i = 0; i < 6; i++) { 
                    // 模拟耗时,突出线程是否阻塞 
                    try { 
                        Thread.sleep(100); 
                    } catch (InterruptedException e) { 
                        e.printStackTrace(); 
                    } 
                    System.out.println(Thread.currentThread().getName() + " doOtherThing, i = " + i); 
                } 
            }finally { 
                mReentrantLock.unlock(); 
            } 
 
        } 
    } 
 
    public static void main(String[] var0) { 
        final Counter counter = new Counter(); 
        new Thread(new Runnable() { 
            @Override 
            public void run() { 
                counter.count(); 
            } 
        }).start(); 
        new Thread(new Runnable() { 
            @Override 
            public void run() { 
                counter.doOtherThing(); 
            } 
        }).start(); 
    } 
}

DEMO3 输出:

Thread-0, i = 0 
Thread-0, i = 1 
Thread-0, i = 2 
Thread-0, i = 3 
Thread-0, i = 4 
Thread-0, i = 5 
Thread-1 doOtherThing, i = 0 
Thread-1 doOtherThing, i = 1 
Thread-1 doOtherThing, i = 2 
Thread-1 doOtherThing, i = 3 
Thread-1 doOtherThing, i = 4 
Thread-1 doOtherThing, i = 5

结合 DEMO2 和 DEMO3 输出可见,锁的作用域在于 mReentrantLock,因为所来自于 mReentrantLock。

可终止等待

DEMO4:

public class Test { 
 
    static final int TIMEOUT = 300; 
 
    private static class Counter { 
 
        private ReentrantLock mReentrantLock = new ReentrantLock(); 
 
        public void count() { 
            try{ 
                //lock() 不可中断 
                mReentrantLock.lock(); 
                // 模拟耗时,突出线程是否阻塞 
                for (int i = 0; i < 6; i++) { 
                    long startTime = System.currentTimeMillis(); 
                    while (true) { 
                        if (System.currentTimeMillis() - startTime > 100) 
                            break; 
                    } 
                    System.out.println(Thread.currentThread().getName() + ", i = " + i); 
                } 
            } finally { 
                // 必须在 finally 释放锁 
                mReentrantLock.unlock(); 
            } 
        } 
 
        public void doOtherThing(){ 
            try{ 
                //lockInterruptibly() 可中断,若线程没有中断,则获取锁 
                mReentrantLock.lockInterruptibly(); 
                for (int i = 0; i < 6; i++) { 
                    // 模拟耗时,突出线程是否阻塞 
                    long startTime = System.currentTimeMillis(); 
                    while (true) { 
                        if (System.currentTimeMillis() - startTime > 100) 
                            break; 
                    } 
                    System.out.println(Thread.currentThread().getName() + " doOtherThing, i = " + i); 
                } 
            } catch (InterruptedException e) { 
                System.out.println(Thread.currentThread().getName() + " 中断 "); 
            }finally { 
                // 若当前线程持有锁,则释放 
                if(mReentrantLock.isHeldByCurrentThread()){ 
                    mReentrantLock.unlock(); 
                } 
            } 
        } 
    } 
 
    public static void main(String[] var0) { 
        final Counter counter = new Counter(); 
        new Thread(new Runnable() { 
            @Override 
            public void run() { 
                counter.count(); 
            } 
        }).start(); 
        Thread thread2 = new Thread(new Runnable() { 
            @Override 
            public void run() { 
                counter.doOtherThing(); 
            } 
        }); 
        thread2.start(); 
        long start = System.currentTimeMillis(); 
        while (true){ 
            if (System.currentTimeMillis() - start > TIMEOUT) { 
                // 若线程还在运行,尝试中断 
                if(thread2.isAlive()){ 
                    System.out.println(" 不等了,尝试中断 "); 
                    thread2.interrupt(); 
                } 
                break; 
            } 
        } 
    } 
}

DEMO4 输出:

Thread-0, i = 0 
Thread-0, i = 1 
Thread-0, i = 2 
不等了,尝试中断 
Thread-1 中断 
Thread-0, i = 3 
Thread-0, i = 4 
Thread-0, i = 5

线程 thread2 等待 300ms 后 timeout,中断等待成功。

若把 TIMEOUT 改成 3000ms,输出结果:(正常运行)

Thread-0, i = 0 
Thread-0, i = 1 
Thread-0, i = 2 
Thread-0, i = 3 
Thread-0, i = 4 
Thread-0, i = 5 
Thread-1 doOtherThing, i = 0 
Thread-1 doOtherThing, i = 1 
Thread-1 doOtherThing, i = 2 
Thread-1 doOtherThing, i = 3 
Thread-1 doOtherThing, i = 4 
Thread-1 doOtherThing, i = 5

定时锁

DEMO5:

public class Test { 
 
    static final int TIMEOUT = 3000; 
 
    private static class Counter { 
 
        private ReentrantLock mReentrantLock = new ReentrantLock(); 
 
        public void count() { 
            try{ 
                //lock() 不可中断 
                mReentrantLock.lock(); 
                // 模拟耗时,突出线程是否阻塞 
                for (int i = 0; i < 6; i++) { 
                    long startTime = System.currentTimeMillis(); 
                    while (true) { 
                        if (System.currentTimeMillis() - startTime > 100) 
                            break; 
                    } 
                    System.out.println(Thread.currentThread().getName() + ", i = " + i); 
                } 
            } finally { 
                // 必须在 finally 释放锁 
                mReentrantLock.unlock(); 
            } 
        } 
 
        public void doOtherThing(){ 
            try{ 
                //tryLock(long timeout, TimeUnit unit) 尝试获得锁 
                boolean isLock = mReentrantLock.tryLock(300, TimeUnit.MILLISECONDS); 
                System.out.println(Thread.currentThread().getName() + " isLock:" + isLock); 
                if(isLock){ 
                    for (int i = 0; i < 6; i++) { 
                        // 模拟耗时,突出线程是否阻塞 
                        long startTime = System.currentTimeMillis(); 
                        while (true) { 
                            if (System.currentTimeMillis() - startTime > 100) 
                                break; 
                        } 
                        System.out.println(Thread.currentThread().getName() + " doOtherThing, i = " + i); 
                    } 
                }else{ 
                    System.out.println(Thread.currentThread().getName() + " timeout"); 
                } 
            } catch (InterruptedException e) { 
                System.out.println(Thread.currentThread().getName() + " 中断 "); 
            }finally { 
                // 若当前线程持有锁,则释放 
                if(mReentrantLock.isHeldByCurrentThread()){ 
                    mReentrantLock.unlock(); 
                } 
            } 
        } 
    } 
 
    public static void main(String[] var0) { 
        final Counter counter = new Counter(); 
        new Thread(new Runnable() { 
            @Override 
            public void run() { 
                counter.count(); 
            } 
        }).start(); 
        Thread thread2 = new Thread(new Runnable() { 
            @Override 
            public void run() { 
                counter.doOtherThing(); 
            } 
        }); 
        thread2.start(); 
    } 
}

DEMO5 输出:

Thread-0, i = 0 
Thread-0, i = 1 
Thread-0, i = 2 
Thread-1 isLock:false 
Thread-1 timeout 
Thread-0, i = 3 
Thread-0, i = 4 
Thread-0, i = 5

tryLock() 尝试获得锁,tryLock(long timeout, TimeUnit unit) 在给定的 timeout 时间内尝试获得锁,若超时,则不带锁往下走,所以必须加以判断。

ReentrantLock or synchronized

ReentrantLock 、synchronized 之间如何选择?

ReentrantLock 在性能上 比 synchronized 更胜一筹。

ReentrantLock 需格外小心,因为需要显式释放锁,lock() 后记得 unlock(),而且必须在 finally 里面,否则容易造成死锁。

synchronized 隐式自动释放锁,使用方便。

ReentrantLock 扩展性好,可中断锁,定时锁,自由控制。

synchronized 一但进入阻塞等待,则无法中断等待。

发布评论

分享到:

IT虾米网

微信公众号号:IT虾米 (左侧二维码扫一扫)欢迎添加!

Java 多线程并发编程之 Synchronized 关键字详解
你是第一个吃螃蟹的人
发表评论

◎欢迎参与讨论,请在这里发表您的看法、交流您的观点。