并发编程进阶

DBC 727 0

1.考查是否知道并发编程三要素

并发编程三要素是否知道,能否分别解释下,举个简单的例子

原子性
原子性

:一个不可再被分割的颗粒,原子性指的是一个或多个操作要么全部执行成功要么全部执行失败,期间不能被中断,也不存在上下文切换,线程切换会带来原子性的问题
int num = 1; // 原子操作
num++; // 非原子操作,从主内存读取num到线程工作内存,进行 +1,再把num写到主内存, 除非用原子类,即java.util.concurrent.atomic里的原子变量类

解决办法:可以用synchronized 或 Lock(比如ReentrantLock) 来把这个多步操作“变成”原子操作,但是volatile,前面有说到不能修饰有依赖值的情况

public class XdTest {
    private int num = 0;

    //使用lock,每个对象都是有锁,只有获得这个锁才可以进行对应的操作
    Lock lock = new ReentrantLock();
    public  void add1(){
        lock.lock();
        try {
            num++;
        }finally {
            lock.unlock();
        }
    }

    //使用synchronized,和上述是一个操作,这个是保证方法被锁住而已,上述的是代码块被锁住
    public synchronized void add2(){
        num++;
    }
}
温馨提示

解决核心思想:把一个方法或者代码块看做一个整体,保证是一个不可分割的整体

有序性
有序性

: 程序执行的顺序按照代码的先后顺序执行,因为处理器可能会对指令进行重排序
JVM在编译java代码或者CPU执行JVM字节码时,对现有的指令进行重新排序,主要目的是优化运行效率(不改变程序结果的前提)
int a = 3 //1
int b = 4 //2
int c =5 //3
int h = a*b*c //4

上面的例子 执行顺序1,2,3,4 和 2,1,3,4 结果都是一样,指令重排序可以提高执行效率,但是多线程上可能会影响结果

假如下面的场景,正常是顺序处理
//线程1
before();//处理初始化工作,处理完成后才可以正式运行下面的run方法
flag = true; //标记资源处理好了,如果资源没处理好,此时程序就可能出现问题
//线程2
while(flag){
run(); //核心业务代码
}

指令重排序后,导致顺序换了,程序出现问题,且难排查

//线程1
flag = true; //标记资源处理好了,如果资源没处理好,此时程序就可能出现问题
//线程2
while(flag){
run(); //核心业务代码
}
before();//处理初始化工作,处理完成后才可以正式运行下面的run方法

可见性
可见性

: 一个线程A对共享变量的修改,另一个线程B能够立刻看到
// 线程 A 执行
int num = 0;
// 线程 A 执行
num++;
// 线程 B 执行
System.out.print("num的值:" + num);

线程A执行 i++ 后再执行线程 B,线程 B可能有2个结果,可能是0和1。

因为 i++ 在线程A中执行运算,并没有立刻更新到主内存当中,而线程B就去主内存当中读取并打印,此时打印的就是0;也可能线程A执行完成更新到主内存了,线程B的值是1。
所以需要保证线程的可见性
synchronized、lock和volatile能够保证线程可见性

2.常见的进程、线程间调度算法

说下你知道的调度算法,比如进程间的调度

并发编程进阶插图

先来先服务调度算法

按照作业/进程到达的先后顺序进行调度 ,即:优先考虑在系统中等待时间最长的作业
排在长进程后的短进程的等待时间长,不利于短作业/进程

短作业优先调度算法

短进程/作业(要求服务时间最短)在实际情况中占有很大比例,为了使得它们优先执行
对长作业不友好

高响应比优先调度算法

在每次调度时,先计算各个作业的优先权:优先权=响应比=(等待时间+要求服务时间)/要求服务时间,
因为等待时间与服务时间之和就是系统对该作业的响应时间,所以 优先权=响应比=响应时间/要求服务时间,选择优先权高的进行服务需要计算优先权信息,增加了系统的开销
并发编程进阶插图2

时间片轮转调度算法

轮流的为各个进程服务,让每个进程在一定时间间隔内都可以得到响应
由于高频率的进程切换,会增加了开销,且不区分任务的紧急程度

优先级调度算法

根据任务的紧急程度进行调度,高优先级的先处理,低优先级的慢处理
如果高优先级任务很多且持续产生,那低优先级的就可能很慢才被处理

常见的线程间的调度算法是怎样的,java是哪种

线程调度是指系统为线程分配CPU使用权的过程,主要分两种

协同式线程调度(分时调度模式)

线程执行时间由线程本身来控制,线程把自己的工作执行完之后,要主动通知系统切换到另外一个线程上。最大好处是实现简单,且切换操作对线程自己是可知的,没啥线程同步问题。坏处是线程执行时间不可控制,如果一个线程有问题,可能一直阻塞在那里

抢占式线程调度

每个线程将由系统来分配执行时间,线程的切换不由线程本身来决定(Java中,Thread.yield()可以让出执行时间,但无法获取执行时间)。线程执行时间系统可控,也不会有一个线程导致整个进程阻塞

解析

Java线程调度就是抢占式调度,优先让可运行池中优先级高的线程占用CPU,如果可运行池中的线程优先级相同,那就随机选择一个线程

所以我们如果希望某些线程多分配一些时间,给一些线程少分配一些时间,可以通过设置线程优先级来完成。
JAVA的线程的优先级,以1到10的整数指定。当多个线程可以运行时,VM一般会运行最高优先级的线程(Thread.MIN_PRIORITY至Thread.MAX_PRIORITY)

在两线程同时处于就绪runnable状态时,优先级越高的线程越容易被系统选择执行。但是优先级并不是100%可以获得,只不过是机会更大而已。

有人会说,wait,notify不就是线程本身控制吗?
其实不是,wait是可以让出执行时间,notify后无法获取执行时间,随机等待队列里面获取而已

3.考查对常见的锁是否掌握

你日常开发里面用过java里面有哪些锁?分别解释下

悲观锁

当线程去操作数据的时候,总认为别的线程会去修改数据,所以它每次拿数据的时候都会上锁,别的线程去拿数据的时候就会阻塞,比如synchronized

乐观锁

每次去拿数据的时候都认为别人不会修改,更新的时候会判断是别人是否回去更新数据,通过版本来判断,如果数据被修改了就拒绝更新,比如CAS是乐观锁,但严格来说并不是锁,通过原子性来保证数据的同步,比如说数据库的乐观锁,通过版本控制来实现,CAS不会保证线程同步,乐观的认为在数据更新期间没有其他线程影响

小结:悲观锁适合写操作多的场景,乐观锁适合读操作多的场景,乐观锁的吞吐量会比悲观锁多
公平锁

指多个线程按照申请锁的顺序来获取锁,简单来说 如果一个线程组里,能保证每个线程都能拿到锁 比如ReentrantLock(底层是同步队列FIFO:First Input First Output来实现)

非公平锁

获取锁的方式是随机获取的,保证不了每个线程都能拿到锁,也就是存在有线程饿死,一直拿不到锁,比如synchronized、ReentrantLock

小结:非公平锁性能高于公平锁,更能重复利用CPU的时间
可重入锁

也叫递归锁,在外层使用锁之后,在内层仍然可以使用,并且不发生死锁

不可重入锁

若当前线程执行某个方法已经获取了该锁,那么在方法中尝试再次获取锁时,就会获取不到被阻塞

小结:可重入锁能一定程度的避免死锁 synchronized、ReentrantLock 重入锁
    private void meathA(){
            //获取锁 TODO
        meathB();
    }
​
    private void meathB(){
            //获取锁 TODO
            //其他操作
    }
自旋锁

一个线程在获取锁的时候,如果锁已经被其它线程获取,那么该线程将循环等待,然后不断的判断锁是否能够被成功获取,直到获取到锁才会退出循环,任何时刻最多只能有一个执行单元获得锁.

小结:不会发生线程状态的切换,一直处于用户态,减少了线程上下文切换的消耗,缺点是循环会消耗CPU

常见的自旋锁:TicketLock,CLHLock,MSCLock

共享锁

也叫S锁/读锁,能查看但无法修改和删除的一种数据锁,加锁后其它用户可以并发读取、查询数据,但不能修改,增加,删除数据,该锁可被多个线程所持有,用于资源数据共享

互斥锁

也叫X锁/排它锁/写锁/独占锁/独享锁/ 该锁每一次只能被一个线程所持有,加锁后任何线程试图再次加锁的线程会被阻塞,直到当前线程解锁。例子:如果 线程A 对 data1 加上排他锁后,则其他线程不能再对 data1 加任何类型的锁,获得互斥锁的线程即能读数据又能修改数据

死锁

两个或两个以上的线程在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞的现象,若无外力作用,它们都将无法让程序进行下去并发编程进阶插图4
线程A、B都有各自的锁,这时候A想去要B的锁,B又想去要A的锁,但是锁都被占用了,这时候就形成了死锁,如果都不放弃各自的锁的话!

下面三种是Jvm为了提高锁的获取与释放效率而做的优化 针对Synchronized的锁升级,锁的状态是通过对象监视器在对象头中的字段来表明,是不可逆的过程
偏向锁

一段同步代码一直被一个线程所访问,那么该线程会自动获取锁,获取锁的代价更低

轻量级锁

当锁是偏向锁的时候,被其他线程访问,偏向锁就会升级为轻量级锁,其他线程会通过自旋的形式尝试获取锁,但不会阻塞,且性能会高点

重量级锁

当锁为轻量级锁的时候,其他线程虽然是自旋,但自旋不会一直循环下去,当自旋一定次数的时候且还没有获取到锁,就会进入阻塞,该锁升级为重量级锁,重量级锁会让其他申请的线程进入阻塞,性能也会降低

还有一些其他的锁:分段锁、行锁、表锁

4.考查对常见的死锁是否掌握

上机实战:写个多线程死锁的例子

小例子

线程在获得了锁A并且没有释放的情况下去申请锁B,
这时另一个线程已经获得了锁B,在释放锁B之前又要先获得锁A
因此闭环发生,陷入死锁循环

public class DeadLockDemo {
    private static String locka = "locka";

    private static String lockb = "lockb";

    public void methodA(){
        synchronized (locka){
            System.out.println("我是A方法中获得了锁A"+Thread.currentThread().getName());
            //让出CPU执行权,不释放锁
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lockb){
                System.out.println("我是A方法中获得了锁B"+Thread.currentThread().getName());
            }
        }
    }

    public void methodB(){
        synchronized (lockb){
            System.out.println("我是A方法中获得了锁B"+Thread.currentThread().getName());
            //让出CPU执行权,不释放锁
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (locka){
                System.out.println("我是B方法中获得了锁A"+Thread.currentThread().getName());
            }
        }
    }

    public static void main(String[] args) {
        System.out.println("主线程运行开始:"+Thread.currentThread().getName());
        DeadLockDemo deadLockDemo = new DeadLockDemo();
        new Thread(()->{
            deadLockDemo.methodA();
        }).start();
        new Thread(()->{
            deadLockDemo.methodB();
        }).start();
        System.out.println("主线程运行结束:"+Thread.currentThread().getName());
    }
}
控制台输出
解析

这里的sleep是模拟在执行的业务代码,来保证一定会出现死锁,你写代码的时候可能不会出现死锁,但是有时候又会出现,就是这个原因了!并发编程进阶插图6

注意:这里看到控制台已经输出了内容,但是程序并没有结束,就一直卡在这里了!
线上经常会产生诡异的情况,有可能是死锁,且难排查!!!

死锁的4个必要条件

互斥条件:资源不能共享,只能由一个线程使用
请求与保持条件:线程已经获得一些资源,但因请求其他资源发生阻塞,对已经获得的资源保持不释放
不可抢占:有些资源是不可强占的,当某个线程获得这个资源后,系统不能强行回收,只能由线程使用完自己释放
循环等待条件:多个线程形成环形链,每个都占用对方申请的下个资源

只要发生死锁,上面的条件都成立;只要一个不满足,就不会发生死锁

那上面的例子怎么解决死锁,优化下代码

思想

常见的解决办法:
调整申请锁的范围
调整申请锁的顺序

/**
 * 解决死锁,通过调整锁的范围
 */
public class DeadLockDemo {
    private static String locka = "locka";

    private static String lockb = "lockb";

    public void methodA(){
        synchronized (locka){
            System.out.println("我是A方法中获得了锁A"+Thread.currentThread().getName());
            //让出CPU执行权,不释放锁
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
        synchronized (lockb){
            System.out.println("我是A方法中获得了锁B"+Thread.currentThread().getName());
        }
    }

    public void methodB(){
        synchronized (lockb){
            System.out.println("我是A方法中获得了锁B"+Thread.currentThread().getName());
            //让出CPU执行权,不释放锁
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        synchronized (locka){
            System.out.println("我是B方法中获得了锁A"+Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) {
        System.out.println("主线程运行开始:"+Thread.currentThread().getName());
        DeadLockDemo deadLockDemo = new DeadLockDemo();
        new Thread(()->{
            deadLockDemo.methodA();
        }).start();
        new Thread(()->{
            deadLockDemo.methodB();
        }).start();
        System.out.println("主线程运行结束:"+Thread.currentThread().getName());
    }
}
控制台输出

5.考查对常见的不可重入锁是否掌握

上机实战:设计一个简单的不可重入锁

/**
 * 不可重入锁
 *
 * 不可重入锁:若当前线程执行某个方法已经获取了该锁,那么在方法中尝试再次获取锁时,就会获取不到被阻塞
 */
public class UnreentrantLock {

    private boolean isLocked = false;

    public synchronized void lock(){
        System.out.println("进入lock加锁"+Thread.currentThread().getName());
        //判断是否已经被锁,如果被锁则当前请求的线程进行等待
        while (isLocked){
            System.out.println("进入wart等待"+Thread.currentThread().getName());
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //如果没有被锁,进行加锁

        isLocked = true;
    }

    public synchronized void unlock(){
        System.out.println("进入unlock解锁"+Thread.currentThread().getName());
        isLocked = false;
        //唤醒对象锁池里面的一个线程
        notify();
    }
}

public class Main {


    private UnreentrantLock unreentrantLock = new UnreentrantLock();


    //加锁建议在try里面,解锁建议在finally
    public void  methodA(){

        try {
            unreentrantLock.lock();
            System.out.println("methodA方法被调用");
            methodB();

        } finally {
            unreentrantLock.unlock();
        }

    }

    public void methodB(){

        try {
            unreentrantLock.lock();
            System.out.println("methodB方法被调用");

        } finally {
            unreentrantLock.unlock();
        }

    }


    public static void main(String [] args){

        //演示的是同个线程
        new Main().methodA();

    }

}
控制台输出
温馨提示

同一个线程,重复获取锁失败,形成死锁,这个就是不可重入锁

6.考查对常见的重入锁是否掌握

上机实战:设计一个简单的可重入锁

/**
 * 可重入锁
 * <p>
 * 可重入锁:也叫递归锁,在外层使用锁之后,在内层仍然可以使用,并且不发生死锁
 */
public class ReentrantLock {

    private boolean isLocked = false;

    //用于记录是不是重入的线程
    private Thread lockedOwner = null;

    //累计加锁次数,加锁一次累计加一,解锁一次减少1
    private int lockedCount = 0;

    public synchronized void lock() throws InterruptedException {
        System.out.println("进入lock加锁" + Thread.currentThread().getName());

        Thread thread = Thread.currentThread();


        //判断是否是同个线程获取锁,引用地址的比较
        while (isLocked && lockedOwner != thread) {
            System.out.println("进入wart等待" + Thread.currentThread().getName());
            System.out.println("当前锁状态 isLocked = " + isLocked);
            System.out.println("当前count数量 lockedCount = " + lockedCount);
            wait();

        }

        //如果没有被锁,进行加锁
        isLocked = true;
        lockedOwner = thread;
        lockedCount++;
    }

    public synchronized void unlock() {
        System.out.println("进入unlock解锁" + Thread.currentThread().getName());

        Thread thread = Thread.currentThread();
        //线程A加的锁,只能由线程A解锁,其他线程B不能解锁
        if (thread==this.lockedOwner){
            lockedCount--;
            if (lockedCount==0){
                isLocked = false;
                lockedOwner = null;
                //唤醒对象锁池里面的一个线程
                notify();
            }
        }

    }
}


public class Main {


    private ReentrantLock reentrantLock = new ReentrantLock();


    //加锁建议在try里面,解锁建议在finally
    public void  methodA(){

        try {
            reentrantLock.lock();
            System.out.println("methodA方法被调用");
            methodB();

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            reentrantLock.unlock();
        }

    }

    public void methodB(){

        try {
            reentrantLock.lock();
            System.out.println("methodB方法被调用");

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            reentrantLock.unlock();
        }

    }


    public static void main(String [] args){

        //演示的是同个线程
        new Main().methodA();

    }

}
控制台输出
温馨提示

可重入锁:也叫递归锁,在外层使用锁之后,在内层仍然可以使用,并且不发生死锁

7.考查对常见的synchronized是否掌握,新版JDK6里面优化了什么

对synchronized了解不,能否介绍下你对synchronized的理解

温馨提示

synchronized是解决线程安全的问题,常用在 同步普通方法、静态方法、代码块 中

非公平、可重入

每个对象有一个锁和一个等待队列,锁只能被一个线程持有,其他需要锁的线程需要阻塞等待。锁被释放后,对象会从队列中取出一个并唤醒,唤醒哪个线程是不确定的,不保证公平性

两种形式:
:生成的字节码文件中会多一个 ACC_SYNCHRONIZED 标志位,当一个线程访问方法时,会去检查是否存在ACC_SYNCHRONIZED标识,如果存在,执行线程将先获取monitor,获取成功之后才能执行方法体,方法执行完后再释放monitor。在方法执行期间,其他任何线程都无法再获得同一个monitor对象,也叫隐式同步

代码块:加了 synchronized 关键字的代码段,生成的字节码文件会多出 monitorenter 和 monitorexit 两条指令,每个monitor维护着一个记录着拥有次数的计数器, 未被拥有的monitor的该计数器为0,当一个线程获执行monitorenter后,该计数器自增1;当同一个线程执行monitorexit指令的时候,计数器再自减1。当计数器为0的时候,monitor将被释放.也叫显式同步

两种本质上没有区别,底层都是通过monitor来实现同步, 只是方法的同步是一种隐式的方式来实现,无需通过字节码来完成

jdk1.6后进行了优化,你知道哪些大的变化

温馨提示

有得到锁的资源进入Block状态,涉及到操作系统用户模式和内核模式的切换,代价比较高
jdk6进行了优化,增加了从偏向锁到轻量级锁再到重量级锁的过渡,但是在最终转变为重量级锁之后,性能仍然较低

8.考查对常见的CAS是否掌握

了解CAS不,能否解释下什么是CAS

温馨提示

全称是Compare And Swap,即比较再交换,是实现并发应用到的一种技术
底层通过Unsafe类实现原子性操作操作包含三个操作数 —— 内存地址(V)、预期原值(A)和新值(B)。
如果内存位置的值与预期原值相匹配,那么处理器会自动将该位置值更新为新值 ,若果在第一轮循环中,a线程获取地址里面的值被b线程修改了,那么a线程需要自旋,到下次循环才有可能机会执行。

CAS这个是属于乐观锁,性能较悲观锁有很大的提高
AtomicXXX 等原子类底层就是CAS实现,一定程度比synchonized好,因为后者是悲观锁

并发编程进阶插图8

9.并发编程面试核心点CAS常见存在的问题考查

CAS会存在什么比较严重的问题?

温馨提示

1、自旋时间长CPU利用率增加,CAS里面是一个循环判断的过程,如果线程一直没有获取到状态,cpu资源会一直被占用

2、存在ABA问题

能否解释下什么是ABA问题,怎么避免这个问题呢?

温馨提示

如果一个变量V初次读取是A值,并且在准备赋值的时候也是A值,那就能说明A值没有被修改过吗?其实是不能的,因为变量V可能被其他线程改回A值,结果就是会导致CAS操作误认为从来没被修改过,从而赋值给V

给变量加一个版本号即可,在比较的时候不仅要比较当前变量的值 还需要比较当前变量的版本号。
在java5中,已经提供了AtomicStampedReference来解决问题,检查当前引用是否等于预期引用,其次检查当前标志是否等于预期标志,如果都相等就会以原子的方式将引用和标志都设置为新值

并发编程进阶插图10

发表评论 取消回复
表情 图片 链接 代码

分享