并发面试题1：synchronized和lock的区别

最新推荐文章于 2024-02-22 17:10:08 发布

此生辽阔

最新推荐文章于 2024-02-22 17:10:08 发布

阅读量342

点赞数

分类专栏：多线程

本文链接：https://blog.csdn.net/ningmengshuxiawo/article/details/115608095

版权

多线程专栏收录该内容

16 篇文章 2 订阅

订阅专栏

保证线程安全

用synchronized修饰方法或者代码块
lock给代码块加锁

synchronized和lock的区别

synchronized属于jvm层面，是java的关键字，lock是API层面，是java5以后的一个接口
synchronized底层主要是monitorenter和monitorexit
monitorenter(底层是通过monitor对象来完成，其实wait /notify等方法也依赖于monitor对象,所以只有在同步块或方法中才能调wait/notify等方法
在这里插入图片描述
synchronized是可重入锁

1：作用位置不同
synchronized修饰普通方法，默认的锁对象是当前对象，synchronized修饰静态方法，默认的锁对象是当前类的class对象，比如User.class,synchronized修饰代码块，自己设置锁对象
lock只能给代码块加锁

2：获取锁和释放锁的机制不同
synchronized无需手动获取锁和释放锁，代码执行完自动释放锁，发生异常会自动释放锁，不会发生死锁
lock需要自己加锁和释放锁，如lock()和unlock(),如果忘记unlock(),就会发生死锁，所以，一般在finally里面使用unlock()

3：等待是否可中断
synchronized不可中断，除非抛出异常或者正常执行完成
ReentranLock可中断

1：设置超时方法tryLock（long timeout,TimeUnit unit）
2：lockInterruptibly()放入代码块中，调用interrupt()方法可中断

4：加锁是否公平
synchronized默认非公平锁
ReentranLock两者都可以，默认是非公平锁，构造方法可以传入boolean值，true为公平锁，false为非公平锁

 /**
     * Creates an instance of {@code ReentrantLock}.
     * This is equivalent to using {@code ReentrantLock(false)}.
     */
    public ReentrantLock() {
        sync = new NonfairSync();
    }

/**
     * Creates an instance of {@code ReentrantLock} with the
     * given fairness policy.
     *
     * @param fair {@code true} if this lock should use a fair ordering policy
     */
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

5：锁绑定多个条件Condition（一个ReentrantLock对象可以同时绑定多个对象）
synchronized没有condition这个说法（synchronized使用Object对象本身的wait 、notify、notifyAll调度机制，而Lock可以使用Condition进行线程之间的调度）

ReentrantLock用来实现分组唤醒需要唤醒的线程们，可以精确唤醒，而不是像synchronized要么随机唤醒一个线程要么唤醒全部线程。
（比如用A线程唤醒B线程，B线程执行完唤醒C线程，这种交替，精确唤醒）

例题：
题目:多线程之间按顺序调用，实现A->B->C三个线程启动，要求如下:AA打印5次，BB打印10次，CC打印15次
紧接着
AA打印5次，BB打印10次，CC打印15次
来10轮

这个题目用synchronized写就会很麻烦，用lock写就可以实现精确唤醒

因为是线程操作资源类，首先定义一个资源类

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

public class lockTest {
    public static void main(String[] args) {
        ShareSource shareSource = new ShareSource();
        new Thread(()->{
            for (int i = 1; i <=10; i++) {
                shareSource.print5();//A线程循环10次，每一次调用print5
            }
        },"A").start();
        new Thread(()->{
            for (int i = 1; i <=10; i++) {
                shareSource.print10();//A线程循环10次，每一次调用print5
            }
        },"B").start();
        new Thread(()->{
            for (int i = 1; i <=10; i++) {
                shareSource.print15();//A线程循环10次，每一次调用print5
            }
        },"C").start();
    }
}

//因为是线程操作资源类，首先定义一个资源类
class ShareSource{
    private int number=1;//A:1,B:2,C:3
    private Lock lock=new ReentrantLock();

   //一把锁里面有3把备用钥匙
    private Condition c1=lock.newCondition();
    private Condition c2=lock.newCondition();
    private Condition c3=lock.newCondition();

    // 1判断
    public void print5()
    {
        lock.lock();
        try {
               //多线程中为了避免虚假唤醒，使用while循环
            while(number!=1)
            {
                c1.await();//等待进程
            }
            //2 干活
            for (int i = 1; i <= 5; i++) {
                //System.out.print(Thread.currentThread().getName()+"\t"+i);
                System.out.print("AA\t");
            }
            System.out.println();
            //3 通知
            number=2;//修改标志位
            c2.signal();//通知线程2


        } catch(Exception e){
            e.printStackTrace();
        }
        finally {
            lock.unlock();
        }
    }


    // 1判断
    public void print10()
    {
        lock.lock();
        try {
            //多线程中为了避免虚假唤醒，使用while循环
            while(number!=2)
            {
                c2.await();

            }
            //2 干活
            for (int i = 1; i <= 10; i++) {
                //System.out.println(Thread.currentThread().getName()+"\t"+i);
                System.out.print("BB\t");
            }
            System.out.println();
            //3 通知
            number=3;//修改标志位
            c3.signal();//通知线程3
        } catch(Exception e){
            e.printStackTrace();
        }
        finally {
            lock.unlock();
        }
    }

    // 1判断
    public void print15()
    {
        lock.lock();
        try {
            //多线程中为了避免虚假唤醒，使用while循环
            while(number!=3)
            {
                c3.await();

            }
            //2 干活
            for (int i = 1; i <= 15; i++) {
                //System.out.println(Thread.currentThread().getName()+"\t"+i);
                System.out.print("CC\t");
            }
            System.out.println();
            //3 通知
            number=1;//修改标志位
            c1.signal();//通知线程1
        } catch(Exception e){
            e.printStackTrace();
        }
        finally {
            lock.unlock();
        }
    }
}