当前位置:   article > 正文

synchronized/Lock锁详解_lock修饰的代码块怎么保证同步

lock修饰的代码块怎么保证同步

在这里插入图片描述

synchronized/Lock

synchronized

synchronized是Java中的关键字,是一种同步锁

synchronized保证同一时刻有且只有一条线程在操作临界资源,其他线程必须等待该线程处理结束后再对共享数据进行操作。此时便产生了互斥锁,互斥锁特性如下:

  • 互斥性:在同一时刻只允许一条线程持有某个对象锁,通过这种特性来实现多线程协调机制,这样就实现了在同一时刻只有一条线程对所需要同步的代码块(符合操作)进行访问。互斥性也成了操作的原子性。
  • 可见性:必须确保在锁释放之前,对共享变量所做的修改,对于随后获得该锁的另一线程可见(也就是在获得锁时应获得最新共享变量的值),否则另一线程可能会在本地缓存上继续操作,从而引起数据的不一致。

synchronized关键字保证同一时刻最多只有1个线程执行被synchronized修饰的方法/代码,其他线程必须等待当前线程执行完该方法/代码块后才能执行该方法/代码块。

同步代码块
  • 修饰某一处代码块,被修饰的代码块称为同步代码块。作用范围是{}之间;作用的对象是调用这个代码块的对象。
synchronized (this){
    System.out.println("同步代码块 ");
}
  • 1
  • 2
  • 3
  • 修饰某个类。作用范围是{}之间;作用的对象是这个类的所有对象。
class Ticket {
    public void sale() {
        synchronized (Ticket.class) {
            // 操作临界资源
        }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
同步方法
  • 修饰在方法上,被修饰的方法称为同步方法。作用范围是整个方法;作用对象是调用这个方法的对象。
public synchronized void sale() {
    // ......
}
  • 1
  • 2
  • 3
  • 修饰某个静态方法。作用范围是整个静态方法;作用对象是这个类的所有对象。
public static synchronized void test(){
    // ......     
}
  • 1
  • 2
  • 3
案例——卖票
public class SynchronizedDemo {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        
        new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        }, "A").start();

        new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        }, "C").start();
    }
}

class Ticket {
    // 票数
    private int number = 30;

    // 操作方法:卖票
    public synchronized void sale() {
        // 判断是否有余票
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() + " : " + (number--) + " " + number);
        }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
总结

获取锁的线程释放锁的情况:

  • 正常执行结束,自动释放锁;
  • 执行过程中发生异常,JVM让线程自动释放锁。

synchronized的同步效率很低,如果某个代码块被其修饰,当一线程进入synchronized修饰的代码块,那么其余线程只能一直等待,等待持有锁的线程释放锁,才能进入同步代码块。

Lock

如果持有锁的线程由于要等待IO或其他原因(如调用sleep方法),被阻塞了,但是没有释放锁,其他线程就只能等待,非常影响程序性能。因此需要一种机制可以不让等待的线程一直无期限的等待下去(如只等待一定时间,或能够响应中断),通过Lock可以解决。如lock可以判断线程是否成功获取到锁,而synchronized无法做到。

锁类型
  • 可重入锁
  • 可中断锁
  • 公平锁
  • 读写锁
Lock接口
public interface Lock {

    // 获得锁
    // 如果锁不可用,则当前线程将被禁用以进行线程调度,并处于休眠状态,直到获取锁
    // lock()方法不能被中断,一旦陷入死锁,lock()会进入无限等待
    void lock();

    // 除非当前线程被中断,否则获取锁
    // 如果锁不可用,则当前线程将被禁用以进行线程调度,并处于休眠状态,直到出现以下两种情况之一:
    //     1.锁被当前线程获取
    //     2.其他线程中断当前线程,支持中断获取锁
    // 和lock()方法不同的是在锁的获取中可以中断当前线程
    // 如果当前线程在进入此方法时已设置其中断状态
    // 那么获取锁时被中断,并且支持获取锁的中断,然后抛出InterruptedException并清除当前线程的中断状态
    void lockInterruptibly() throws InterruptedException; 

    // 非阻塞获取锁(如果有),并立即返回true;如果锁不可用,则立即返回false
    // 该方法会立即返回,即使拿不到锁的时候也不会一直在那等待
    // 我们可以根据是否能获取到锁来决定后续程序的行为
    boolean tryLock();
    
    // 如果线程在给定的等待时间内获取到锁,且当前线程未中断,则获取锁
    // 如果锁可用,则此方法立即返回true
    // 如果不可用,则出于线程调度目的,当前线程将被挂起,处于休眠状态,直到发生以下3种情况之一:
    //     1.锁被当前线程获取
    //     2.其他线程中断当前线程,支持中断获取锁
    //     3.经过指定的等待时间如果获得了锁,则返回true
    // 如果经过了指定的等待时间,未获得锁,则返回false。如果时间小于等于0,则该方法不需等待
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;  

     // 解锁
    void unlock(); 
    
    // 返回绑定到此Lock实例的新Condition实例
    Condition newCondition();
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
lock()/unlock()

如果使用了lock,必须主动释放锁,就算发生了异常,也需要手动释放,因为lock不会像synchronized一样自动释放锁。所以使用lock,必须在try{}catch(){}中进行,并在finally{}中释放锁,防止死锁。

Lock lock = new ReentrantLock();
try {
    lock.lock();
    System.out.println("上锁了");
}catch (Exception e){
    e.printStackTrace();
}finally {
    lock.unlock();
    System.out.println("解锁了");
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
newCondition

关键字synchronized与wait()/notify()一起使用可以实现等待/通知。Lock锁的newCondition()方法返回Condition对象,Condition类也可以实现等待/通知。使用notify()时,JVM会随机唤醒某个等待的线程,使用Condition类可以选择性通知,Condition常用的两个方法:

  • await():使当前线程进入等待状态,同时释放锁。等到其他线程调用signal()方法时,这个沉睡线程会重新获得锁并继续执行代码(在哪沉睡在哪唤醒)
  • signal():用于唤醒一个等待的线程。

注意

在调用Condition的await()/signal()方法前,也需要线程持有相关的Lock锁,调用await()后线程会释放这个锁,在调用signal()后,会从当前Condition对象的等待队列中,唤醒一个线程,被唤醒的线程开始尝试获取锁,一旦成功获得锁就继续往下执行。

例子:

有两个线程,一个初始值是0的number变量,一个线程当number == 0时,对number值+1,另外一个线程当number == 1时,对number-1:

public class LockDemo {
    public static void main(String[] args) {
        Share share = new Share();

        new Thread(()->{
            for (int i=0;i<=10;i++){
                share.incr();
            }
        },"AA").start();

        new Thread(()->{
            for (int i=0;i<=10;i++){
                share.decr();
            }
        },"BB").start();
        /**
         * AA::1
         * BB::0
         * AA::1
         * BB::0
         * .....
         */     
    }
}

class Share {

    private Integer number = 0;

    private ReentrantLock lock = new ReentrantLock();

    private Condition newCondition = lock.newCondition();

    // +1 的方法
    public void incr() {
        try {
            // 加锁
            lock.lock();
            while (number != 0) {
                // 沉睡
                newCondition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName() + "::" + number);
            // 唤醒另一个沉睡的线程 
            newCondition.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    // -1 的方法
    public void decr() {
        try {
            lock.lock();
            while (number != 1) {
                newCondition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName() + "::" + number);
            newCondition.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
ReentrantLock可重入锁

ReentrantLock是唯一实现了Lock接口的类,且提供了更多的方法。

可重入锁:某个线程已经获得某个锁,可以再次获取锁而不会死锁。

public class ReentrantLockDemo {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock.lock();
                    System.out.println("第1次获取锁,这个锁是:" + lock);
                    for (int i = 2;i<=11;i++){
                        try {
                            lock.lock();
                            System.out.println("第" + i + "次获取锁,这个锁是:" + lock);
                            try {
                                Thread.sleep(new Random().nextInt(200));
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        } finally {
                           // 注意:一定要释放锁。如果把这里注释掉的话,那么程序就会陷入死锁当中
                           lock.unlock();
                        }
                    }

                } finally {
                    lock.unlock();
                }
            }
        }).start();
    }
}
/**
 * 第1次获取锁,这个锁是:java.util.concurrent.locks.ReentrantLock@6b5fde1f[Locked by thread Thread-0]
 * 第2次获取锁,这个锁是:java.util.concurrent.locks.ReentrantLock@6b5fde1f[Locked by thread Thread-0]
 * 第3次获取锁,这个锁是:java.util.concurrent.locks.ReentrantLock@6b5fde1f[Locked by thread Thread-0]
 * ...
 */
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
ReadWriteLock读写锁
public interface ReadWriteLock {
  
    // 获取读锁
    Lock readLock();

  // 获取写锁
    Lock writeLock();
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

读写分离,可以有多个线程进行读操作,提高效率。

ReentrantReadWriteLock实现了ReadWriteLock接口。提供了更丰富的方法,最重要的还是获取读锁和写锁。

案例——多个线程进行读操作

// synchronized加锁
public class SynchronizedDemo {

    public static void main(String[] args) {
        final SynchronizedDemo test = new SynchronizedDemo();
        new Thread(()->{
            test.get(Thread.currentThread());
        }).start();

        new Thread(()->{
            test.get(Thread.currentThread());
        }).start();
    }

    public synchronized void get(Thread thread) {
        long start = System.currentTimeMillis();
        while(System.currentTimeMillis() - start <= 1) {
            System.out.println(thread.getName()+"正在进行读操作");
        }
        System.out.println(thread.getName()+"读操作完毕");
    }
}

/*
结果:
Thread-0正在进行读操作
Thread-0读操作完毕
Thread-1正在进行读操作
Thread-1正在进行读操作
......
......
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1读操作完毕
*/

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
// 读锁
public class ReentrantReadWriteLockDemo {

    private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    
    public static void main(String[] args) {
        final ReentrantReadWriteLockDemo test = new ReentrantReadWriteLockDemo();
        new Thread(()->{
            test.get2(Thread.currentThread());
        }).start();

        new Thread(()->{
            test.get2(Thread.currentThread());
        }).start();
    }

    public void get2(Thread thread) {
        rwl.readLock().lock();
        try {
            long start = System.currentTimeMillis();
            while(System.currentTimeMillis() - start <= 1) {
                System.out.println(thread.getName()+"正在进行读操作");
            }
            System.out.println(thread.getName()+"读操作完毕");
        } finally {
            rwl.readLock().unlock();
        }
    }
}

/*
结果:
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
......
Thread-0正在进行读操作
Thread-1正在进行读操作
......
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-0正在进行读操作
......
Thread-0正在进行读操作
Thread-1正在进行读操作
Thread-0读操作完毕
Thread-1读操作完毕
*/
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49

结论:

使用读锁,线程1和线程2可以同时读,提高了效率。

注意

  1. 如果此时已经有线程持有了读锁,其他线程是可以申请读锁的,但是不能申请写锁,需要等待读锁释放,才能获得锁。
  2. 如果此时已经有线程持有了写锁,其他线程无论申请读锁还是写锁,都需要持有写锁的线程释放锁,才能成功获得。
synchronized和Lock的区别
声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/956066
推荐阅读
相关标签
  

闽ICP备14008679号