【Java面试】并发

- 日理万妓 2024-03-31 15:13 48阅读 0赞

#### 文章目录 ####

*  线程有那些状态？
 *  一个程序来显示状态切换过程
 *   *  正常执行流程
     *  阻塞执行流程
     *  等待执行流程
 *  说说线程池的核心参数
 *  wait和sleep的区别
 *  Lock和synchronized的区别
 *  Lock中Condition的使用
 *  说说Java中的悲观锁与乐观锁
 *   *  乐观锁
     *  悲观锁
 *  Hashtable和ConcurrentHashMap的区别？
 *  【Java面试】谈一谈你对ThreadLocal的理解

## 线程有那些状态？ ##

操作系统层面将线程状态分为5种，分别是：新建，就绪，运行，阻塞，死亡  
但是在Java的Thread类中，线程的状态枚举如下：  
![在这里插入图片描述][06951a42407949c7ac62a55e3a38e302.png]  
**也就是Java将线程分为了六种状态：创建，可运行，阻塞，等待，限时等待和终结**  
![在这里插入图片描述][db3c6a95b9d442c2a8d419647779ae6c.png]  
新建状态指的是我们使用new方法新建出来一个线程对象的时候，此时Java还没有将其与OS关联起来，那么这个线程就不会被分配CPU去执行代码，只有调用了start方法之后才会与真正的线程关联起来，此时就从新建状态变为了可运行（就绪）状态，等待分配CPU去执行任务，如果CPU分配给了当前线程，当前线程就会执行对应的任务，任务执行完毕之后，当前线程死亡（终结），注意是死亡，此时这个任务对应的线程以及资源都会被释放。  
而并不是所有的任务都会被执行，因此会有部分任务进行阻塞，例如多线程访问同一个锁资源的时候，如果当前线程没有得到锁，那么当前线程就需要进行阻塞，此时CPU被分配给得到锁的线程去执行任务，任务执行完毕之后，锁释放，线程再次去争夺锁，得到锁的话就可以从阻塞状态变为可运行状态，此时只需要等待CPU分配资源就可以运行了。  
而当前持锁线程可能执行任务后发现有些条件不满足，那么这个线程不能总是占有锁，因此可以选择调用wait方法去释放锁，然后让自己进入等待状态去等待条件的满足，此时其他线程就可以去竞争锁从而执行他们的任务，等到条件满足，就可以由另一个线程调用notify方法去提醒这个线程再次竞争锁去完成任务。  
最后一种是等待的一种情况，叫做现时等待，也就是这次等待可以设定时间。  
方法是使用wait方法并且设定等待的时间，再次之前如果时间到了或者另一个线程调用了notify方法，那么这个线程就会被唤醒。  
还有一种是sleep方法，这种方法和wait不一样，sleep是不会释放当前线程的锁的，其他线程都得陪着这个线程等，这个线程等待完毕之后在继续执行接下来的任务，调用了sleep方法相对于是告诉CPU你现在先不用执行我的任务了，你可以先去干其他的，相当于让出CPU资源。

## 一个程序来显示状态切换过程 ##

### 正常执行流程 ###

首先来两个断点，一个断点打在主线程上，另一个断点打在分支上。  
并且设定触发断点的条件为Thread，这样子我们进入debug状态之后就可以以线程作为操控条件了。  
![在这里插入图片描述][f899494401934536b0c86292a3b23d4b.png]  
![在这里插入图片描述][792c2a4ce26a4a56944a22023c2d3b63.png]  
主线程断点设置在了最后一句，所以此时前面的语句都已经执行完毕了，但是由于还有一个断点打在了分支线程里面，所以如果我不让他执行，他就得等待  
![在这里插入图片描述][dd6207b0bd8944348c4f0ae03cd096fd.png]  
现在切换到分支线程执行语句  
![在这里插入图片描述][3d3a0c3eb7e543738c39282a11317652.png]  
![在这里插入图片描述][7c06b3d79b144c8d95ae1615053b2919.png]  
此时分支线程的任务已经执行完毕了，那么只有主线程还有任务了。  
让主线程执行断点处的语句  
![在这里插入图片描述][7d2d7d045d424168bc478ac3761434c1.png]  
可以发现在没有阻塞的情况下，线程状态为NEW->RUNNABLE->TERMINATED  
这几个状态都是Thread类中定义的枚举类型。

### 阻塞执行流程 ###

要让线程阻塞，就让他获取锁失败就行了  
![在这里插入图片描述][8c724adaafad442fa6fd3e24c71e5a11.png]  
首先先创建线程，然后开启线程，但是不让线程执行任务  
![在这里插入图片描述][c33de434baae470ca8bf6a80e3604389.png]  
开启任务之后，先让分支线程执行一下，然后让他触碰到获取锁的位置但是先不执行，然后让主线程去执行获取锁的方法，然后再切换到分支线程去获取锁，此时分支线程获取锁失败，那么再让主线程打印分支线程的状态，此时的状态就是阻塞了。  
之后主线程释放锁，分支线程继续执行任务，分支线程变为RUNNABLE状态，然后执行完成任务后死亡。  
![在这里插入图片描述][5b3a5332c62241f8a852631cf4508f07.png]

### 等待执行流程 ###

大致流程也是差不多的，先让分支线程获取到锁，然后此时分支线程调用wait方法把锁让出去，那么主线程就能得到锁，然后查看此时分支线程的状态，主线程把分支线程唤醒之后，分支线程的状态从WAITTING变为了BLOCKING，因为此时分支线程要继续执行任务的话就需要获得锁。  
得到锁之后继续重新执行任务，此时主线程发现分支线程的状态就是RUNNABLE了，然后分支线程执行完毕任务，死亡。  
![在这里插入图片描述][0f33de4fdaad4ae697399c6ed6686998.png]

## [说说线程池的核心参数][Link 1] ##

线程池的执行流程也就是主线程（业务线程）提交任务到线程池之后，任务的处理流程。  
下面来看execute方法  
![在这里插入图片描述][8bcc4efcb62f48e4985e94bb1b2663f3.png]  
这个方法首先判断要执行的任务是否是空，如果是，返回一个空指针异常。否则，判断当前的工作线程数，如果工作线程数小于核心线程数，那么直接创建一个工作线程执行任务，如果不是，那么判断当前工作队列是否不满，如果是，那么将这个任务放入到工作队列中，如果不是，判断当前是否还有可用的非核心线程（判断maximumPoolSize-corePoolSize>0）即工作线程数是否大于最大线程数，如果不是，那么创建一个非核心线程来执行当前任务，如果是，那么就执行拒绝策略。流程图如下：  
![在这里插入图片描述][798734d02bce48888b4aff74902cc6a5.png]

## wait和sleep的区别 ##

*  共同点:  
    wait(),wait(long)和sleep(long)的效果都是让当前线程暂时放弃CPU的使用权，进入阻塞状态
 *  方法归属不同  
    sleep(long)是 Thread的静态方法  
    而wait(),wait(long)都是Object的成员方法，每个对象都有，因此每一个对象都可以作为锁来调用这个方法
 *  醒来时机不同  
    执行 sleep(long)和wait(long)的线程都会在等待相应毫秒后醒来  
    wait(long)和 wait()还可以被notify唤醒，wait()如果不唤醒就一直等下去  
    它们都可以被打断唤醒
 *  锁特性不同  
    wait方法的调用必须先获取wait对象的锁，而sleep 则无此限制  
    wait方法执行后会释放对象锁，允许其它线程获得该对象锁（我放弃，但你们还可以用)，而sleep如果在 synchronized代码块中执行，并不会释放对象锁（我放弃，你们也用不了)

## Lock和synchronized的区别 ##

*  语法层面  
    synchronized是关键字，源码在jvm 中，用c++语言实现  
    Lock是接口，源码由jdk 提供，用java语言实现  
    使用synchronized时，退出同步代码块锁会自动释放，而使用Lock时，需要手动调用unlock方法释放锁
 *  功能层面  
    二者均属于悲观锁、都具备基本的互斥、同步、锁重入功能  
    Lock提供了许多synchronized不具备的功能，例如获取等待状态、公平锁、可打断、可超时、多条件变量  
    Lock有适合不同场景的实现，如ReentrantLock,ReentrantReadWriteLock
 *  性能层面  
    在没有竞争时，synchronized做了很多优化，如偏向锁、轻量级锁，性能不赖  
    在竞争激烈时，Lock的实现通常会提供更好的性能

## [Lock中Condition的使用][Lock_Condition] ##

## 说说Java中的悲观锁与乐观锁 ##

1.悲观锁的代表是synchronized和Lock锁

*  其核心思想是【线程只有占有了锁，才能去操作共享变量，每次只有一个线程占锁成功，获取锁失败的线程，都得停下来等待】
 *  线程从运行到阻塞、再从阻塞到唤醒，涉及线程上下文切换，如果频繁发生，影响性能
 *  实际上，线程在获取synchronized和Lock锁时，如果锁已被占用，都会做几次重试操作，减少阻塞的机会

2.乐观锁的代表是Atomiclnteger，使用cas来保证原子性

*  其核心思想是【无需加锁，每次只有一个线程能成功修改共享变量，其它失败的线程不需要停止，不断重试直至成功】
 *  由于线程一直运行，不需要阻塞，因此不涉及线程上下文切换
 *  它需要多核cpu支持，且线程数不应超过cpu核数

### 乐观锁 ###

乐观锁的典型操作就是CAS（compare and set）  
这里按照乐观锁的要求，不加锁，每次失败的时候都重试，直到成功  
当然，如果想要进行原子操作，需要保证共享变量的可见性，所以一般需要要求变量是volatile类型的。

public class SyncVsCas {
        
        static final Unsafe U = Unsafe.getUnsafe();
        //得到偏移位置
        static final long BALANCE = U.objectFieldOffset(Account.class,"balance");
        static class Account{
        
            volatile int balance=10;
        }
    
        public static void main(String[] args) {
        
            Account account = new Account();
            while (true) {
        
                int o = account.balance;
                int n = o+5;
                //第一个参数为：要修改的变量是那个对象的 第二个是偏移量
                //第三个参数为旧值  第四个参数为新值
                //这个方法会把o值和我们共享变量的值进行比对 如果一样那么就修改
                if(U.compareAndSetInt(account, BALANCE, o, n)){
        
                    //原子性的
                    break;
                }
            }
            System.out.println(account.balance);
        }
    }

### 悲观锁 ###

悲观锁就是很典型的使用synchronized

public static void sync(Account account){
        
            Thread t1 = new Thread(()->{
        
                synchronized (account){
        
                    int o = account.balance;
                    int n = o-5;
                    account.balance=n;
                }
            },"t1");
            Thread t2 = new Thread(()->{
        
                synchronized (account){
        
                    int o = account.balance;
                    int n = o+5;
                    account.balance=n;
                }
            },"t2");
            t1.start();
            t2.start();
            System.out.println(account.balance);
    
        }

## [Hashtable和ConcurrentHashMap的区别？][Hashtable_ConcurrentHashMap] ##

## [【Java面试】谈一谈你对ThreadLocal的理解][Java_ThreadLocal] ##

[06951a42407949c7ac62a55e3a38e302.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/199d633bc2ea48a281293f419ce121ab.png
[db3c6a95b9d442c2a8d419647779ae6c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/6a79721208d0486c8f97ae853a27f17b.png
[f899494401934536b0c86292a3b23d4b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/4f3a5a3b5de04636828b7068102cbd87.png
[792c2a4ce26a4a56944a22023c2d3b63.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/70277a87faa94a3cb1ac59127037fb8a.png
[dd6207b0bd8944348c4f0ae03cd096fd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/d10c1d531c964060a677fb596bac9c50.png
[3d3a0c3eb7e543738c39282a11317652.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/110db0aa0a394e4da2f61dd90ae54482.png
[7c06b3d79b144c8d95ae1615053b2919.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/728ce517ee7249b0a2b62269ce9ea0e2.png
[7d2d7d045d424168bc478ac3761434c1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/9b406dff421844d3b88b97d9f14593df.png
[8c724adaafad442fa6fd3e24c71e5a11.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/e9798608e843443da91b1007e99c86e1.png
[c33de434baae470ca8bf6a80e3604389.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/b6f11ba072074bc5a8f8f310ac438203.png
[5b3a5332c62241f8a852631cf4508f07.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/7661beda1d8f48afa8ee57c9e1a76770.png
[0f33de4fdaad4ae697399c6ed6686998.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/76acae64f74c4e24ae2f82b0e2837eb1.png
[Link 1]: https://blog.csdn.net/weixin_46410481/article/details/122864251
[8bcc4efcb62f48e4985e94bb1b2663f3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/218625f53f5943dc959310e9e6499972.png
[798734d02bce48888b4aff74902cc6a5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/308556bb94634143aedb2f3495c8427a.png
[Lock_Condition]: https://blog.csdn.net/hellozpc/article/details/121722896
[Hashtable_ConcurrentHashMap]: https://blog.csdn.net/Zhangsama1/article/details/128068705?spm=1001.2014.3001.5502
[Java_ThreadLocal]: https://blog.csdn.net/Zhangsama1/article/details/128215901?csdn_share_tail=%7B%22type%22:%22blog%22,%22rType%22:%22article%22,%22rId%22:%22128215901%22,%22source%22:%22Zhangsama1%22%7D