面试官突击一问，【备战秋招冲击大厂

8. 线程的创建方式

启动线程有如下三种方式：

• 继承Thread类创建线程类

  （1）定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。

  （2）创建Thread子类的实例，即创建了线程对象。

  （3）调用线程对象的start()方法来启动该线程。

package com.thread；

public class FirstThreadTest extends Thread{

    int i = 0；

    //重写run方法，run方法的方法体就是现场执行体

    public void run(){

        for(；i<100；i++){

            System.out.println(getName()+"  "+i)；

        }

    }

    public static void main(String[] args) {

        for(int i = 0；i< 100；i++){

            System.out.println(Thread.currentThread().getName()+"  ： "+i)；

            if(i==20) {

                new FirstThreadTest().start()；

                new FirstThreadTest().start()；

            }

        }

    }

} 

上述代码中Thread.currentThread()方法返回当前正在执行的线程对象。GetName()方法返回调用该方法的线程的名字。

• 通过Runnable接口创建线程类：使用实现Runnable接口的方式创建的线程可以处理同一资源，从而实现资源的共享.

  • 适合多个相同程序代码的线程去处理同一个资源（多线程内的数据共享）

  • 增加程序健壮性，数据被共享时，仍然可以保持代码和数据的分离和独立

  • 避免java特性中的单继承限制

  • 更能体现java面向对象的设计特点

    （1）定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。

    （2）创建 Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。

    （3）调用线程对象的start()方法来启动该线程。

package com.thread；

public class RunnableThreadTest implements Runnable{

    private int i；

    public void run(){

        for(i = 0；i <100；i++){

            System.out.println(Thread.currentThread().getName()+" "+i)；

        }

    }

    public static void main(String[] args) {

        for(int i = 0；i < 100；i++){

            System.out.println(Thread.currentThread().getName()+" "+i)；

            if(i==20){

                RunnableThreadTest rtt = new RunnableThreadTest()；

                new Thread(rtt，"新线程1").start()；

                new Thread(rtt，"新线程2").start()；

            }

        }

    }

} 

• 通过Callable和Future创建线程

  （1）创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。

  （2）创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。

  （3）使用FutureTask对象作为Thread对象的target创建并启动新线程。

  （4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

package com.thread；

import java.util.concurrent.Callable；

import java.util.concurrent.ExecutionException；

import java.util.concurrent.FutureTask；

 

public class CallableThreadTest implements Callable<Integer>{

     public static void main(String[] args) {

        CallableThreadTest ctt = new CallableThreadTest()；

        FutureTask<Integer> ft = new FutureTask<>(ctt)；

        for(int i = 0；i < 100；i++){

            System.out.println(Thread.currentThread().getName()+" 的变量i的值"+i)；

            if(i==20) {

                new Thread(ft，"有返回值的线程").start()；

            }

        }

        try{

            System.out.println("子线程的返回值："+ft.get())；

        } catch (InterruptedException e) {

            e.printStackTrace()；

        } catch (ExecutionException e) {

            e.printStackTrace()；

        }

    }

 

    @Override

    public Integer call() throws Exception{

        int i = 0；

        for(；i<100；i++){

            System.out.println(Thread.currentThread().getName()+" "+i)；

        }

        return i；

    }

} 

9. cyclicbarrier和countdownlatch的区别

• CountDownLatch和CyclicBarrier都能够实现线程之间的等待

• CountDownLatch一般用于某个线程A或多个线程，等待若干个其他线程执行完任务之后，它才执行；CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量；调用await()方法的线程会被阻塞，直到计数器减到 0 的时候，才能继续往下执行；调用了await()进行阻塞等待的线程，它们阻塞在Latch门闩/栅栏上；只有当条件满足的时候（countDown() N次，将计数减为0），它们才能同时通过这个栅栏；以此能够实现，让所有的线程站在一个起跑线上。

• CyclicBarrier一般用于一组线程互相等待至某个状态，然后这一组线程再同时执行；另外，CountDownLatch是减计数，计数减为0后不能重用；而CyclicBarrier是加计数，可置0后复用。

10. Java中提供的线程池

Executors类提供了4种不同的线程池：newCachedThreadPool， newFixedThreadPool， newScheduledThreadPool， newSingleThreadExecutor

1)newCachedThreadPool：用来创建一个可以无限扩大的线程池，适用于负载较轻的场景，执行短期异步任务。（可以使得任务快速得到执行，因为任务时间执行短，可以很快结束，也不会造成cpu过度切换）

2)newFixedThreadPool：创建一个固定大小的线程池，因为采用无界的阻塞队列，所以实际线程数量永远不会变化，适用于负载较重的场景，对当前线程数量进行限制。（保证线程数可控，不会造成线程过多，导致系统负载更为严重）

3)newSingleThreadExecutor：创建一个单线程的线程池，适用于需要保证顺序执行各个任务。

4)newScheduledThreadPool：适用于执行延时或者周期性任务。

11. 自定义线程池（ThreadPoolExector）

new ThreadPoolExecutor(

                    2，

                    9，

                    1L，

                    TimeUnit.SECONDS，

                    new LinkedBlockingDeque<Runnable>(10)，

                    Executors.defaultThreadFactory()，

                    new ThreadPoolExecutor.DiscardPolicy())； 

七大参数：

1)corePoolSize（常驻核心线程数）：当向线程池提交一个任务时，若线程池已创建的线程数小于corePoolSize，即便此时存在空闲线程，也会通过创建一个新线程来执行该任务，直到已创建的线程数大于或等于corePoolSize时，（除了利用提交新任务来创建和启动线程（按需构造），也可以通过 prestartCoreThread() 或 prestartAllCoreThreads() 方法来提前启动线程池中的基本线程。）

2)maximumPoolSize（线程池最大线程数）：线程池所允许的最大线程个数。当队列满了，且已创建的线程数小于maximumPoolSize，则线程池会创建新的线程来执行任务。另外，对于无界队列，可忽略该参数。

3)keepAliveTime（线程存活保持时间）当线程池中线程数大于核心线程数时，线程的空闲时间如果超过线程存活时间，那么这个线程就会被销毁，直到线程池中的线程数小于等于核心线程数。

4)unit(时间单位)

5)workQueue（任务队列）：用于传输和保存等待执行任务的阻塞队列。

6)threadFactory（线程工厂）：用于创建新线程。threadFactory创建的线程也是采用new Thread()方式，threadFactory创建的线程名都具有统一的风格：pool-m-thread-n（m为线程池的编号，n为线程池内的线程编号）。

handler（线程饱和策略）：当线程池和队列都满了，再加入线程会执行此策略。

• 四种拒绝策略：

  1)ThreadPoolExecutor.AbortPolicy(默认)：丢弃任务并抛出RejectedExecutionException异常。

  2)ThreadPoolExecutor.DiscardPolicy：丢弃任务，但是不抛出异常。

  3)ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新提交被拒绝的任务

  4)ThreadPoolExecutor.CallerRunsPolicy：由调用线程（提交任务的线程）处理该任务

• 配置线程池

  1)CPU密集型任务：尽量使用较小的线程池，一般为CPU核心数+1。 因为CPU密集型任务使得CPU使用率很高，若开过多的线程数，会造成CPU过度切换。

  2)IO密集型任务：可以使用稍大的线程池，一般为2*CPU核心数。IO密集型任务CPU使用率并不高，因此可以让CPU在等待IO的时候有其他线程去处理别的任务，充分利用CPU时间。CPU核心线程数/1-阻塞系数（0.8~0.9）

  3)混合型任务：可以将任务分成IO密集型和CPU密集型任务，然后分别用不同的线程池去处理。

12. 线程池的状态

• RUNNING：这是最正常的状态，接受新的任务，处理等待队列中的任务。线程池的初始化状态是RUNNING。线程池被一旦被创建，就处于RUNNING状态，并且线程池中的任务数为0。

• SHUTDOWN：不接受新的任务提交，但是会继续处理等待队列中的任务。调用线程池的shutdown()方法时，线程池由RUNNING -> SHUTDOWN。

• STOP：不接受新的任务提交，不再处理等待队列中的任务，中断正在执行任务的线程。调用线程池的shutdownNow()方法时，线程池由(RUNNING or SHUTDOWN ) -> STOP。

• TIDYING（整理状态）：所有的任务都销毁了，workCount 为 0，线程池的状态在转换为 TIDYING 状态时，会执行钩子方法 terminated()。因为terminated()在ThreadPoolExecutor类中是空的，所以用户想在线程池变为TIDYING时进行相应的处理；可以通过重载terminated()函数来实现。

• TERMINATED：线程池处在TIDYING状态时，执行完terminated()之后，就会由 TIDYING -> TERMINATED。

  

更多Java学习资料、面试真题获得，请【点击此处】

13. 线程池中shutdown()和shutdownNow()方法的区别

shutdown只是将线程池的状态设置为SHUTWDOWN状态，正在执行的任务会继续执行下去，没有被执行的则中断。而shutdownNow则是将线程池的状态设置为STOP，正在执行的任务则被停止，没被执行任务的则返回。

14. 线程池中 submit() 和 execute() 方法的区别

• execute()：只能执行 Runnable 类型的任务。

• submit()：可以执行 Runnable 和 Callable 类型的任务。

• submit()能获取返回值（异步）以及处理Exception。

15. ThreadLocal

https：//segmentfault.com/a/1190000037728236?utm_source=tag-newest

ThreadLocal提供了线程内存储变量的能力，这些变量不同之处在于每一个线程读取的变量是对应的互相独立的。通过get和set方法就可以得到当前线程对应的值。

• ThreadLocal和Synchronized都是为了解决多线程中相同变量的访问冲突问题，不同的点是：

• Synchronized是通过线程等待，牺牲时间来解决访问冲突

• ThreadLocal是通过每个线程单独一份存储空间，牺牲空间来解决冲突，并且相比于Synchronized，ThreadLocal具有线程隔离的效果，只有在线程内才能获取到对应的值，线程外则不能访问到想要的值。

• 应用场景

• 数据库连接池的实现：获取connection

• 提升性能和安全，如SimpleDateFormat

• 底层实现

  1)ThreadLocal仅仅是个变量访问的入口；

  2)每一个Thread对象都有一个ThreadLocalMap对象，这个ThreadLocalMap持有对象的引用；

  3)ThreadLocalMap以当前的threadLocal对象为key，以真正的存储对象为value。get()方法时通过threadLocal实例就可以找到绑定在当前线程上的副本对象。

• 每个线程都有一个属于自己的ThreadLocalMap类， 他用于关联多个以ThreadLocal对象为key， 以你的数据为value的Entry对象， 且该对象的key是一个弱引用对象，以防止内存泄漏。

  

16. Synchronized在静态方法和非静态方法的区别

• Synchronzied 修饰非静态方法==》对象锁（同步代码块，方法锁）

• Synchronzied 修饰静态方法==》类锁，因为是静态方法，它把整个类锁起来了；

17. Synchronized和Lock

• 实现层面不一样。synchronized 是Java关键字，JVM层面实现加锁和释放锁；Lock 是一个接口，在代码层面实现加锁和释放锁

• 是否自动释放锁。synchronized 在线程代码执行完或出现异常时自动释放锁；Lock 不会自动释放锁，需要再 finally{}代码块显式地中释放锁

• 是否一直等待。synchronized 会导致线程拿不到锁一直等待；Lock 可以设置尝试获取锁或者获取锁失败一定时间超时

• 获取锁成功是否可知。synchronized 无法得知是否获取锁成功；Lock 可以通过 tryLock 获得加锁是否成功

• 功能复杂性。synchronized 加锁可重入、不可中断、非公平；Lock 可重入、可判断、可公平和不公平、细分读写锁提高效率

18. Synchronized和Volatile

• synchronized 可以作用于变量、方法、对象；volatile 只能作用于变量。

• synchronized 可以保证线程间的有序性（个人猜测是无法保证线程内的有序性，即线程内的代码可能被 CPU 指令重排序）、原子性和可见性；volatile 只保证了可见性和有序性，禁止指令重排序，无法保证原子性。

• synchronized 线程阻塞，volatile 线程不阻塞。

• volatile 本质是告诉jvm当前变量在寄存器中的值是不安全的需要从内存中读取；sychronized 则是锁定当前变量，只有当前线程可以访问到，该变量其他线程被阻塞。

• volatile 标记的变量不会被编译器优化；synchronized 标记的变量可以被编译器优化。

19. copyonwrite

• 实现就是写时复制，在往集合中添加数据的时候，先拷贝存储的数组，然后添加元素到拷贝好的数组中，然后用现在的数组去替换成员变量的数组（就是get等读取操作读取的数组）。这个机制和读写锁是一样的，但是比读写锁有改进的地方，那就是读取的时候可以写入的 ，这样省去了读写之间的竞争，看了这个过程，你也发现了问题，同时写入的时候怎么办呢，当然果断还是加锁。

• 适用场景：copyonwrite的机制虽然是线程安全的，但是在add操作的时候不停的拷贝是一件很费时的操作，所以使用到这个集合的时候尽量不要出现频繁的添加操作，而且在迭代的时候数据也是不及时的，数据量少还好说，数据太多的时候，实时性可能就差距很大了。在多读取，少添加的时候，他的效果还是不错的。

20. synchronized可重入的实现

每个锁关联一个线程持有者和一个计数器。当计数器为0时表示该锁没有被任何线程持有，那么任何线程都都可能获得该锁而调用相应方法。当一个线程请求成功后，JVM会记下持有锁的线程，并将计数器计为1。此时其他线程请求该锁，则必须等待。而该持有锁的线程如果再次请求这个锁，就可以再次拿到这个锁，同时计数器会递增。当线程退出一个synchronized方法/块时，计数器会递减，如果计数器为0则释放该锁。

21. Lock（锁）

1)公平锁：线程申请锁的顺序来获取锁

2)非公平锁：允许加塞

3)自旋锁：循环方式获取锁

4)独占锁：写锁

5)共享锁：读锁

6)互斥锁：读写锁 

22. 非公平锁和公平锁在reetrantlock里的实现

对于非公平锁，只要CAS设置同步状态成功，则表示当前线程获取了锁，而公平锁还需要判断当前节点是否有前驱节点，如果有，则表示有线程比当前线程更早请求获取锁，因此需要等待前驱线程获取并释放锁之后才能继续获取锁。

23. 死锁

• 定义：两个线程或两个以上线程因争夺资源而出现线程互相等待的现象。

• 原因：

  1)循环等待条件：若干资源形成一种头尾相接的循环等待资源关系。

  2)互斥条件：一个资源一次只能被一个进程访问。

  3)请求保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。进程至少已经占有一个资源，但又申请新的资源；由于该资源已被另外进程占有，此时该进程阻塞；但是，它在等待新资源之时，仍继续占用已占有的资源。

  4)不剥夺条件：进程已经获得的资源，在未使用完之前不能强行剥夺，而只能由该资源的占有者进程自行释放。

• 解决方法：

  • 银行家算法，操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。当进程在执行中继续申请资源时，先测试该进程本次申请的资源数是否超过了该资源所剩余的总量。若超过则拒绝分配资源，若能满足则按当前的申请量分配资源，否则也要推迟分配。

  • 一种非常简单的避免死锁的方式就是：指定获取锁的顺序，并强制线程按照指定的顺序获取锁。因此，如果所有的线程都是以同样的顺序加锁和释放锁，就不会出现死锁了。

• 问题：CPU达到100%（死循环创建对象也会）

最后

本人也收藏了一份Java面试核心知识点来应付面试，借着这次机会可以免费送给我的读者朋友们

目录：

Java面试核心知识点

一共有30个专题，足够读者朋友们应付面试啦，也节省朋友们去到处搜刮资料自己整理的时间！有需要的朋友戳这里即可免费获取

Java面试核心知识点

已经有读者朋友靠着这一份Java面试知识点指导拿到不错的offer了，各位读者朋友们快来免费获取吧

过了该资源所剩余的总量。若超过则拒绝分配资源，若能满足则按当前的申请量分配资源，否则也要推迟分配。

*   一种非常简单的避免死锁的方式就是：指定获取锁的顺序，并强制线程按照指定的顺序获取锁。因此，如果所有的线程都是以同样的顺序加锁和释放锁，就不会出现死锁了。

• 问题：CPU达到100%（死循环创建对象也会）

最后

本人也收藏了一份Java面试核心知识点来应付面试，借着这次机会可以免费送给我的读者朋友们

目录：

[外链图片转存中…(img-isKMsJmJ-1628237537587)]

Java面试核心知识点

一共有30个专题，足够读者朋友们应付面试啦，也节省朋友们去到处搜刮资料自己整理的时间！有需要的朋友戳这里即可免费获取

[外链图片转存中…(img-AUBgTf9w-1628237537589)]

Java面试核心知识点

已经有读者朋友靠着这一份Java面试知识点指导拿到不错的offer了，各位读者朋友们快来免费获取吧

[外链图片转存中…(img-7GfzNS9Q-1628237537591)]