Java中的锁：synchronized和Lock

2019-05-06 本文已影响0人 Cris_Ma

互斥锁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

Java中的锁：synchronized和Lock

互斥锁synchronized

Lock

ReentrantLock

公平锁和非公平锁：

ReadWriteLock 读写锁

Condition

猜你喜欢

热点阅读