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

你可能感兴趣的:(Java中的锁:synchronized和Lock)