JAVA基础知识|synchronized和lock

一、synchronized

是jvm的一个关键字，使用过程均由jvm控制

有三种使用方式：

• 修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁
• 修饰代码块，同方法
• 修饰静态方法，作用于当前类加锁，进入同步代码前要获得当前类对象的锁

1.1、实例方法

作用于实例，会阻塞其他线程访问本实例，但不会影响其他线程访问其他实例

如果实例中有多个synchronized修饰的方法，当其中一个方法被访问时，其他方法也不可以被访问，所以我们在用synchronized关键字的时候，能缩小代码段的范围就尽量缩小，能在代码段上加同步就不要再整个方法上加同步

【示例】

import java.util.concurrent.TimeUnit;

/**
 * Created by jyy on 2018/6/21.
 */
public class SyncTest {

    public synchronized void test1(){
        System.out.println("test1");
        try {
            TimeUnit.SECONDS.sleep(10);
        }catch(InterruptedException ie){
            System.out.println("中断异常");
        }
        System.out.println("test1");
    }

    public synchronized void test2(){
        System.out.println("test2");
    }

    public void test3(){
        System.out.println("test3");
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Created by jyy on 2018/4/19.
 */
public class Test {

    public static void main(String[] args){
        //需要声明为final类型
        final SyncTest syncTest = new SyncTest();
        //线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                syncTest.test1();
            }
        });
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                syncTest.test2();
            }
        });
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                syncTest.test3();
            }
        });
    }
}

执行结果：

test1
test3
test1
test2

1.2、代码块

作用于实例，同上

【示例】

    //新增三个方法
    public void test4(){
        System.out.println("test4");
        synchronized(this){
            try {
                TimeUnit.SECONDS.sleep(10);
            }catch(InterruptedException ie){
                System.out.println("中断异常");
            }
            System.out.println("test4");
        }
    }

    public void test5(){
        System.out.println("test5");
        synchronized(this){
            System.out.println("test5");
        }
    }

    public void test6(){
        System.out.println("test6");
    }

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Created by jyy on 2018/4/19.
 */
public class Test {

    public static void main(String[] args){
        //需要声明为final类型
        final SyncTest syncTest = new SyncTest();
        //线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                syncTest.test4();
            }
        });
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                syncTest.test5();
            }
        });
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                syncTest.test6();
            }
        });
    }
}

执行结果：

test4
test5
test6
test4
test5

从执行结果上，可以看出，当访问关键字synchronized修饰的代码块时，其他synchronized修饰的代码块也会被锁住

1.3、静态方法

作用于类，会阻塞其他线程访问本类的同步方法，即使是不同的实例也不行

【示例】

    //新增方法
    public synchronized static void test7(){
        int random= (new Random()).nextInt(100);
        System.out.println(random);
        try {
            TimeUnit.SECONDS.sleep(10);
        }catch(InterruptedException ie){
            System.out.println("中断异常");
        }
        System.out.println(random);
    }

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Created by jyy on 2018/4/19.
 */
public class Test {

    public static void main(String[] args){
        //线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                SyncTest.test7();
            }
        });
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                SyncTest.test7();
            }
        });
    }
}

执行结果：

69
69
67
67

二、lock

Lock是一个接口，其中lock()、lockInterruptibly()、tryLock()、tryLock(long time, TimeUnit unit)方法可以获取锁，unlock()用来释放锁

 

如果采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用Lock必须在try{}catch{}块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。

2.1、ReentrantLock

ReentrantLock是实现了Lock接口的类，通过它，我们来看下四种获取锁方法的区别

2.1.1、lock()

【示例1】

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

/**
 * Created by jyy on 2018/6/25.
 */
public class ReentrantLockTest {
    private Lock lock = new ReentrantLock();//需要声明为全局变量

    public void test1(){
        lock.lock();//获取锁
        try {
            System.out.println(Thread.currentThread()+"得到了锁");
            TimeUnit.SECONDS.sleep(5);
        } catch (Exception e) {
            System.out.println("发生异常");
        }finally {
            System.out.println(Thread.currentThread()+"释放了锁");
            lock.unlock();
        }
    }
}

        //线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        final ReentrantLockTest reentrantLockTest = new ReentrantLockTest();
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                reentrantLockTest.test1();
            }
        });
       executorService.execute(new Runnable() {
            @Override
            public void run() {
                reentrantLockTest.test1();
            }
        });

执行结果：

Thread[pool-1-thread-1,5,main]得到了锁
Thread[pool-1-thread-1,5,main]释放了锁
Thread[pool-1-thread-2,5,main]得到了锁
Thread[pool-1-thread-2,5,main]释放了锁

【示例2】

        //线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        final ReentrantLockTest reentrantLockTest = new ReentrantLockTest();
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                reentrantLockTest.test1();
            }
        });
        final ReentrantLockTest reentrantLockTest1 = new ReentrantLockTest();
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                reentrantLockTest1.test1();
            }
        });

执行结果：

Thread[pool-1-thread-1,5,main]得到了锁
Thread[pool-1-thread-2,5,main]得到了锁
Thread[pool-1-thread-1,5,main]释放了锁
Thread[pool-1-thread-2,5,main]释放了锁

示例2说明Lock锁住的是实例，而不是类

2.1.2、tryLock()

tryLock()尝试获取锁，获取不到返回false，不影响代码继续执行

【示例】

    //新增方法
    public void test2(){
        if(lock.tryLock())//获取锁
        {
            try {
                System.out.println(Thread.currentThread() + "得到了锁");
                TimeUnit.SECONDS.sleep(5);
            } catch (Exception e) {
                System.out.println("发生异常");
            } finally {
                System.out.println(Thread.currentThread() + "释放了锁");
                lock.unlock();
            }
        }else{
            System.out.println(Thread.currentThread() + "获取锁失败");
        }
    }

        //线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        final ReentrantLockTest reentrantLockTest = new ReentrantLockTest();
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                reentrantLockTest.test2();
            }
        });
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                reentrantLockTest.test2();
            }
        });

执行结果：

Thread[pool-1-thread-1,5,main]得到了锁
Thread[pool-1-thread-2,5,main]获取锁失败
Thread[pool-1-thread-1,5,main]释放了锁

2.1.3、tryLock(long time, TimeUnit unit)

【示例】

    //新增方法
    public void test3() throws InterruptedException {
        if(lock.tryLock(10,TimeUnit.SECONDS))//获取锁
        {
            try {
                System.out.println(Thread.currentThread() + "得到了锁");
                TimeUnit.SECONDS.sleep(5);
            } catch (Exception e) {
                System.out.println("发生异常");
            } finally {
                System.out.println(Thread.currentThread() + "释放了锁");
                lock.unlock();
            }
        }else{
            System.out.println(Thread.currentThread() + "获取锁失败");
        }
    }

        //线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        final ReentrantLockTest reentrantLockTest = new ReentrantLockTest();
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    reentrantLockTest.test3();
                }catch(InterruptedException ie){
                    System.out.println("发生异常");
                }
            }
        });
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    reentrantLockTest.test3();
                }catch(InterruptedException ie){
                    System.out.println("发生异常");
                }
            }
        });

执行结果：

Thread[pool-1-thread-1,5,main]得到了锁
Thread[pool-1-thread-1,5,main]释放了锁
Thread[pool-1-thread-2,5,main]得到了锁
Thread[pool-1-thread-2,5,main]释放了锁

尝试10s获取锁，获取不到才会返回false

2.1.4、lockInterruptibly()

【示例】

    //新增方法
    public void test4() throws InterruptedException {
        lock.lockInterruptibly();
        try {
            System.out.println(Thread.currentThread()+"得到了锁");
            TimeUnit.SECONDS.sleep(10);
        } catch (Exception e) {
            System.out.println("中断成功");
        }finally {
            System.out.println(Thread.currentThread()+"释放了锁");
            lock.unlock();
        }
    }

        final ReentrantLockTest reentrantLockTest = new ReentrantLockTest();
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    reentrantLockTest.test4();
                }catch(InterruptedException ie){
                    System.out.println("发生异常");
                }
            }
        },"1");
        thread1.start();
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (Exception e) {
            System.out.println("延迟5s");
        }
        System.out.println("开始中断");
        thread1.interrupt();//中断thread1
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    reentrantLockTest.test4();
                }catch(InterruptedException ie){
                    System.out.println("发生异常");
                }
            }
        },"2");
        thread2.start();

执行结果：

Thread[1,5,main]得到了锁
开始中断
中断成功
Thread[1,5,main]释放了锁
Thread[2,5,main]得到了锁
Thread[2,5,main]释放了锁

成功中断thread1的锁

三、读写锁

3.1、ReadWriteLock

ReadWriteLock是一个接口，只包含两个方法readLock()、writeLock()

3.2、ReentrantReadWriteLock

ReentrantReadWriteLock实现了ReadWriteLock接口，下面主要说一下ReadLock()、WriteLock()两个方法

 【示例1】

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

/**
 * Created by jyy on 2018/6/26.
 */
public class ReentrantReadWriteLockTest {

    private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

    /**
     * 读锁
     */
    public void test1(){
        rwl.readLock().lock();
        try {
            System.out.println(Thread.currentThread() + "得到了读锁");
            TimeUnit.SECONDS.sleep(5);
        } catch (Exception e) {
            System.out.println("发生异常");
        } finally {
            System.out.println(Thread.currentThread() + "释放了读锁");
            rwl.readLock().unlock();
        }
    }

    /**
     * 写锁
     */
    public void test2(){
        rwl.writeLock().lock();
        try {
            System.out.println(Thread.currentThread() + "得到了写锁");
            TimeUnit.SECONDS.sleep(5);
        } catch (Exception e) {
            System.out.println("发生异常");
        } finally {
            System.out.println(Thread.currentThread() + "释放了写锁");
            rwl.writeLock().unlock();
        }
    }

}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Created by jyy on 2018/4/19.
 */
public class Test {

    public static void main(String[] args) throws InterruptedException {
        final ReentrantReadWriteLockTest reentrantReadWriteLockTest = new ReentrantReadWriteLockTest();
        ExecutorService executorService = Executors.newCachedThreadPool();//连接池
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                reentrantReadWriteLockTest.test1();
            }
        });
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                reentrantReadWriteLockTest.test1();
            }
        });
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                reentrantReadWriteLockTest.test1();
            }
        });
    }
}

执行结果：

Thread[pool-1-thread-1,5,main]得到了读锁
Thread[pool-1-thread-2,5,main]得到了读锁
Thread[pool-1-thread-3,5,main]得到了读锁
Thread[pool-1-thread-3,5,main]释放了读锁
Thread[pool-1-thread-1,5,main]释放了读锁
Thread[pool-1-thread-2,5,main]释放了读锁

多个线程都可以获取到读锁

【示例2】

        executorService.execute(new Runnable() {
            @Override
            public void run() {
                reentrantReadWriteLockTest.test1();
            }
        });
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                reentrantReadWriteLockTest.test1();
            }
        });
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                reentrantReadWriteLockTest.test2();
            }
        });

执行结果：

Thread[pool-1-thread-1,5,main]得到了读锁
Thread[pool-1-thread-2,5,main]得到了读锁
Thread[pool-1-thread-2,5,main]释放了读锁
Thread[pool-1-thread-1,5,main]释放了读锁
Thread[pool-1-thread-3,5,main]得到了写锁
Thread[pool-1-thread-3,5,main]释放了写锁

访问写锁时，必须等读锁全部释放

【示例3】

        executorService.execute(new Runnable() {
            @Override
            public void run() {
                reentrantReadWriteLockTest.test2();
            }
        });
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                reentrantReadWriteLockTest.test1();
            }
        });
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                reentrantReadWriteLockTest.test2();
            }
        });

执行结果：

Thread[pool-1-thread-1,5,main]得到了写锁
Thread[pool-1-thread-1,5,main]释放了写锁
Thread[pool-1-thread-2,5,main]得到了读锁
Thread[pool-1-thread-2,5,main]释放了读锁
Thread[pool-1-thread-3,5,main]得到了写锁
Thread[pool-1-thread-3,5,main]释放了写锁

想要获取读锁，必须先等到写锁释放

总结：

1、如果一个线程占用了读锁，其他线程依然可以获取到这个读锁，但不可以获取到写锁

2、如果一个线程占用了写锁，其他线程不可以获取到读锁和写锁

四、synchronized与lock的区别

1）synchronized是java的一个关键字，而Lock是一个接口

2）synchronized发生异常，会自动释放占有的锁，而Lock必须要主动释放锁，否则会一直处于占用状态

3）Lock中的lockInterruptibly()可以响应中断，而synchronized不可以

4）Lock中的tryLock()可以尝试获取锁，判断是否成功获取到锁，而synchronized不可以

5）ReentrantReadWriteLock可以声明读写锁，提高查询效率

两者不是非一即二的存在，具体使用要看不同的场景

五、锁类型

可重入锁：在执行对象中所有同步方法不用再次获得锁

举个简单的例子，当一个线程执行到某个synchronized方法时，比如说method1，而在method1中会调用另外一个synchronized方法method2，此时线程不必重新去申请锁，而是可以直接执行方法method2

synchronized和ReentrantLock都是可重入锁

可中断锁：在等待获取锁过程中可中断，如ReentrantLock中的lockInterruptibly()

公平锁： 按等待获取锁的线程的等待时间进行获取，等待时间长的具有优先获取锁权利

ReentrantLock默认是非公平锁，可以通过new ReentrantLock(true)声明为公平锁

读写锁：对资源读取和写入的时候拆分为两部分处理，读的时候可以多线程一起读，写的时候必须同步地写，如ReentrantReadWriteLock