Java中的锁：synchronized和Lock

互斥锁synchronized

synchronized是java语言内置功能，访问被synchronized关键字修饰的方法或者代码块时，首先要获得当前方法或者被修饰对象的锁。

任何方法/对象的锁只有一个，所以在同一时刻不可能有两个或以上的线程同时持有，因此被称为互斥锁。直到方法或代码块执行完毕，或者线程异常被结束，锁被释放，其他线程才能获取到锁，执行该方法或代码块。

synchronized使用方法有两种,一是同步方法：


public synchronized void method(){
        //...
    }

或者同步代码块：

private Object o = new Object();

public void method(){

    synchronized(o){
        //....
    }
}

需要注意的是，同一个对象的锁只有一个，不同对象之间是不会相互影响的。如果synchronized修饰的是static方法，因为static是一个类共用一个方法，所以不管什么时候调用该方法都要先获取到锁，非static方法，则只有同一个对象多次调用synchronized方法时才需要获取锁。

Lock

Lock是java.util.concurrent.locks包中的一个接口。与synchronized一样，都是可重入锁：同一个线程可以多次获取同一个锁。

区别主要有以下几点：

Lock需要用户手动释放，并且释放次数需要与获取次数相同，如果释放次数小于获取次数，那么锁不会被释放掉
Lock在获取锁的过程中是可以被打断的（并非执行状态，获取到锁执行程序的过程中是不可能被打断的，只有阻塞状态才能被打断，sleep，join，还有lockInterruptibly。yield是就绪状态，持有锁但是无法被打断）
Lock可以实现公平锁和非公平锁。

Lock接口主要有以下方法：

void lock(); //获取锁,如果锁被其他线程持有，进入等待状态
void lockInterruptibly() throws InterruptedException;//获取可打断锁
boolean tryLock();//尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false,不会等待
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;//可以指定等待时间，等待时可以被打断
void unlock();//释放锁
Condition newCondition();

ReentrantLock

ReentrantLock是实现了Lock接口的类，也是最常用的Lock。


public class Test implements Runnable{

    Lock lock = new ReentrantLock();
    public static void main(String[] args) {
        Test test = new Test();
        for(int i=0; i<5; i++) {
            new Thread(test).start();
            }
    }

    @Override
    public void run() {
        
        System.out.println(Thread.currentThread().getName() + "start.....");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        lock.lock();
        // lock.lock();
        System.out.println(Thread.currentThread().getName() + " get lock.");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            System.out.println(Thread.currentThread().getName() + " release lock.");
            lock.unlock();
        }
    }
}

执行结果如下：

Thread-1start.....
Thread-0start.....
Thread-2start.....
Thread-3start.....
Thread-4start.....
Thread-2 get lock.
Thread-2 release lock.
Thread-0 get lock.
Thread-0 release lock.
Thread-4 get lock.
Thread-4 release lock.
Thread-3 get lock.
Thread-3 release lock.
Thread-1 get lock.
Thread-1 release lock.

可以看到，Lock这里起到了和synchronized同样的效果，只是需要在finally手动释放锁。如果在lock.lock();下边再加一行lock.lock();，让同一个线程获取两次锁，但是在finally里只释放一次，结果就会被阻塞在第一个线程里，锁一直得不到释放，后边的线程一直处于等待状态。

公平锁和非公平锁：

公平锁是指等待时间最长的线程先获取锁，非公平锁是指所有线程同时竞争，默认实现的非公平锁，显然效率要高一些。

还是上边的代码，如果把lock改成公平锁：Lock lock = new ReentrantLock(true);,执行的结果如下：

Thread-1start.....
Thread-2start.....
Thread-0start.....
Thread-4start.....
Thread-3start.....
Thread-1 get lock.
Thread-1 release lock.
Thread-2 get lock.
Thread-2 release lock.
Thread-0 get lock.
Thread-0 release lock.
Thread-4 get lock.
Thread-4 release lock.
Thread-3 get lock.
Thread-3 release lock.

显然是按照等待时间长短来先后获取锁的。

ReadWriteLock 读写锁

ReadWriteLock 也是一个接口，它只有两个方法：

Lock readLock();
Lock writeLock();

分别是获取读锁和写锁，此处把读写分开了，因为写操作是独占的，不可以多个线程同时进行，而读操作是可以的。

public class Test implements Runnable{

    ReadWriteLock lock = new ReentrantReadWriteLock();

    public static void main(String[] args) {
        Test t = new Test();
        for(int i=0; i<5; i++) {
            new Thread(t).start();  
        }
    }
    


    @Override
    public void run() {
        
        lock.readLock().lock();
//      lock.writeLock().lock();
        System.out.println(Thread.currentThread().getName() + "get lock");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {

            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "release lock");
        lock.readLock().unlock();
//      lock.writeLock().unlock();
    }
    
}

执行结果如下：

Thread-0get lock
Thread-1get lock
Thread-2get lock
Thread-3get lock
Thread-4get lock
Thread-1release lock
Thread-0release lock
Thread-2release lock
Thread-3release lock
Thread-4release lock

可以看到，多个线程是同时进行的，如果换成writeLock，就是一个一个线程获取锁了，执行结果如下：

Thread-0get lock
Thread-0release lock
Thread-1get lock
Thread-1release  lock
Thread-2get lock
Thread-2release lock
Thread-3get lock
Thread-3release lock
Thread-4get lock
Thread-4release lock

也就是说，读锁不是互斥锁，而写锁是互斥锁，那么读写锁之间呢？可以看下边的代码：

public class ReadWLock {

    ReadWriteLock lock = new ReentrantReadWriteLock();
    public void read() {
        
        lock.readLock().lock();
        System.out.println(Thread.currentThread().getName() + "get read lock");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "release read lock");
        lock.readLock().unlock();
        
    }
    
    public void write() {
        
        lock.writeLock().lock();
        System.out.println(Thread.currentThread().getName() + "get write lock");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "release write lock");
        lock.writeLock().unlock();
        
    }
}


public static void main(String[] args) {

    ReadWLock t = new ReadWLock();
    new Thread(new Runnable() {
    
        @Override
        public void run() {
        // TODO Auto-generated method stub
        t.read();
        }
    }).start();

    new Thread(new Runnable() {
    
        @Override
        public void run() {
        // TODO Auto-generated method stub
        t.write();
        }
    }).start();

    }

执行结果如下：

Thread-0get read lock
Thread-0release read lock
Thread-1get write lock
Thread-1release write lock

也就是说，读写锁之间也是互斥关系。

注意，ReadWriteLock支持锁降级，但是不支持锁升级：

public static void main(String[] args) {
        ReentrantReadWriteLock rtLock = new ReentrantReadWriteLock();
        rtLock.readLock().lock();
        System.out.println("get readLock.");
        rtLock.writeLock().lock();
        System.out.println("blocking");
    }

上边的代码，先获取了读锁，然后尝试获取写锁，会导致死锁，是不可以的，但是，反过来先申请写锁再申请读锁是可行的。

ReadWriteLock同样支持公平锁。

Condition

Lock中还有一个方法：Condition newCondition()，此方法可以返回一个Condition对象，Condition的主要方法如下：

void await() throws InterruptedException;//类似Object.wait()方法，进入等待状态，释放锁，但是可以被打断
void awaitUninterruptibly();//不能被打断
long awaitNanos(long nanosTimeout) throws InterruptedException;
boolean await(long time, TimeUnit unit) throws InterruptedException;
boolean awaitUntil(Date deadline) throws InterruptedException;
void signal();//类似于notify()
void signalAll();//类似于notifyAll()

Condition常用于线程间的协作，参考以下例子，控制多个线程的执行顺序：

public class ConditionTest {

    Lock lock = new ReentrantLock();
    Condition a = lock.newCondition();
    Condition b = lock.newCondition();
    Condition c = lock.newCondition();

    private char currentChar = 'A';

    public void printA() {
        // 控制A->B->C的输出顺序，所以三个方法必须加锁，不能同步执行，否则顺序必定是不可控的
        lock.lock();
        try {

            try {

                if (currentChar != 'A') {
                    // 当前输出字符不是A的时候，让出锁，程序阻塞在这里，直到可以打印A的时候继续执行
                    a.await();
                }

            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.print('A');
            // A输出完毕，将当前输出字符赋值为B,并通知等待输出B的线程
            currentChar = 'B';
            b.signal();
        } finally {

            lock.unlock();
        }
    }

    public void printB() {
        // 控制A->B->C的输出顺序，所以三个方法必须加锁，不能同步执行，否则顺序必定是不可控的
        lock.lock();
        try {

            try {

                if (currentChar != 'B') {
                    // 当前输出字符不是B的时候，让出锁，程序阻塞在这里，直到可以打印C的时候继续执行
                    b.await();
                }

            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.print('B');
            // B输出完毕，将当前输出字符赋值为C,并通知等待输出C的线程
            currentChar = 'C';
            c.signal();
        } finally {

            lock.unlock();
        }
    }

    public void printC() {
        // 控制A->B->C的输出顺序，所以三个方法必须加锁，不能同步执行，否则顺序必定是不可控的
        lock.lock();
        try {

            try {

                if (currentChar != 'C') {
                    // 当前输出字符不是C的时候，让出锁，程序阻塞在这里，直到可以打印C的时候继续执行
                    c.await();
                }

            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.print('C');
            // B输出完毕，将当前输出字符赋值为C,并通知等待输出C的线程
            currentChar = 'A';
            a.signal();
        } finally {

            lock.unlock();
        }
    }

    public static void main(String... args) {
        ConditionTest test = new ConditionTest();

        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {

                @Override
                public void run() {
                    test.printA();
                }
            }).start();
        }
        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {

                @Override
                public void run() {
                    test.printB();
                }
            }).start();
        }
        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {

                @Override
                public void run() {
                    test.printC();
                }
            }).start();
        }
    }
}

//可以得到输出结果：ABCABCABCABCABC

最后编辑于：2019.05.07 10:49:46

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 161,780评论 4赞 369
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 68,424评论 1赞 305
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 111,397评论 0赞 254
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 44,576评论 0赞 218
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 52,997评论 3赞 295
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 40,945评论 1赞 224
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 32,107评论 2赞 317
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 30,850评论 0赞 208
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 34,625评论 1赞 250
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 30,804评论 2赞 253
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 32,285评论 1赞 265
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 28,613评论 3赞 261
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 33,291评论 3赞 242
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 26,164评论 0赞 8
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 26,963评论 0赞 201
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 36,096评论 2赞 285
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 35,886评论 2赞 278

Java中的锁：synchronized和Lock

互斥锁synchronized

Lock

ReentrantLock

公平锁和非公平锁：

ReadWriteLock 读写锁

Condition

推荐阅读更多精彩内容