Java基础面试题——多线程

多线程

线程基础知识

并发（多线程操作同一个资源）

• CPU 一核 ，模拟出来多条线程，天下武功，唯快不破，快速交替

并行（多个人一起行走）

• CPU 多核 ，多个线程可以同时执行； 线程池

wait/sleep 区别

白嫖资料

• 来自不同的类
  wait => Object
  sleep => Thread
• 关于锁的释放
  wait 会释放锁
  sleep 睡觉了，抱着锁睡觉，不会释放！
• 使用的范围是不同的
  wait必须在同步代码块中
  sleep 可以再任何地方睡
• 是否需要捕获异常
  wait 不需要捕获异常
  sleep 必须要捕获异常

start 与 run 区别

白嫖资料

• start（）方法来启动线程，真正实现了多线程运行。这时无需等待 run 方法体代码执行完毕， 可以直接继续执行下面的代码。
• 通过调用 Thread 类的 start()方法来启动一个线程， 这时此线程是处于就绪状态， 并没有运行。
• 方法 run()称为线程体，它包含了要执行的这个线程的内容，线程就进入了运行状态，开始运 行 run 函数当中的代码。 Run 方法运行结束， 此线程终止。然后 CPU 再调度其它线程。

线程创建

• 继承Thread类
  启动线程的唯一方法就是通过 Thread 类的 start()实例方法。start()方法是一个 native 方法，它将启动一个新线 程，并执行 run()方法
• 实现Runnable接口
  如果自己的类已经 extends 另一个类，就无法直接 extends Thread，此时，可以实现一个 Runnable 接口
• 实现Callable接口
  有返回值的任务必须实现 Callable 接口，类似的，无返回值的任务必须 Runnable 接口
  执行 Callable 任务后，可以获取一个 Future 的对象，在该对象上调用 get 就可以获取到 Callable 任务 返回的 Object 了

Callable线程创建

public class CallableTest {
	public static void main(String[] args) throws ExecutionException,InterruptedException {
        // new Thread(new Runnable()).start();
        // new Thread(new FutureTask<V>()).start();
        // new Thread(new FutureTask<V>( Callable )).start();
        new Thread().start(); // 怎么启动Callable
        MyThread thread = new MyThread();
        FutureTask futureTask = new FutureTask(thread); // 适配类
        new Thread(futureTask,"A").start();
        new Thread(futureTask,"B").start(); // 结果会被缓存，效率高
        Integer o = (Integer) futureTask.get(); //这个get 方法可能会产生阻塞！把他放到
        最后
        // 或者使用异步通信来处理！
        System.out.println(o);
	}
}
class MyThread implements Callable<Integer> {
    @Override
    public Integer call() {
        System.out.println("call()"); // 会打印几个call
        // 耗时的操作
        return 1024;
	}
}

线程池

白嫖资料
Java 里面线程池的顶级接口是 Executor，但是严格意义上讲 Executor 并不是一个线程池，而 只是一个执行线程的工具。真正的线程池接口是 ExecutorService。

线程池：三大方法、七大参数、四种拒绝策略

线程池的好处

• 降低资源的消耗
• 提高响应的速度
• 方便管理。

三大方法

• Executors.newSingleThreadExecutor() 创建一个线程执行
• Executors.newFixedThreadPool(Int i) 创建i个线程执行
• Executors.newCachedThreadPool() 缓存池，可伸缩的， 遇强则强，遇弱则弱

创建代码:

public static void main(String[] args) {
        ExecutorService threadPool = Executors.newSingleThreadExecutor();// 单个线程
        //ExecutorService threadPool = Executors.newFixedThreadPool(5); // 创建一个固定的线程池的大小
        //ExecutorService threadPool = Executors.newCachedThreadPool(); // 可伸缩的，遇强则强，遇弱则弱
        try {
            for (int i = 0; i < 100; i++) {
                // 使用了线程池之后，使用线程池来创建线程
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 线程池用完，程序结束，关闭线程池
            threadPool.shutdown();
        }
    }

七大参数

三大方法源码分析:

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
    (new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS,
    new LinkedBlockingQueue<Runnable>()));
}
public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(5, 5,
    0L, TimeUnit.MILLISECONDS,
    new LinkedBlockingQueue<Runnable>());
}
public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
    60L, TimeUnit.SECONDS,
    new SynchronousQueue<Runnable>());
}
//三大方法都返回ThreadPoolExecutor()类

ThreadPoolExecutor(七大参数)源码分析:

public ThreadPoolExecutor(
    int corePoolSize, // 核心线程池大小
    int maximumPoolSize, // 最大核心线程池大小
    long keepAliveTime, // 超时了没有人调用就会释放
    TimeUnit unit, // 超时单位
    BlockingQueue<Runnable> workQueue, // 阻塞队列
    ThreadFactory threadFactory, // 线程工厂：创建线程的，一般不用动
    RejectedExecutionHandler handle // 拒绝策略) {
        if (corePoolSize < 0 ||maximumPoolSize <= 0 ||maximumPoolSize < corePoolSize ||
        keepAliveTime < 0)
        	throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
        	throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?null:AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
}

四种拒绝策略
白嫖资料

image-20210527134117484

/**
 * new ThreadPoolExecutor.AbortPolicy()         //银行满了，还有人进来，不处理这个人的，抛出异常
 * new ThreadPoolExecutor.CallerRunsPolicy()    //哪来的去哪里！
 * new ThreadPoolExecutor.DiscardPolicy()       //队列满了，丢掉任务，不会抛出异常！
 * new ThreadPoolExecutor.DiscardOldestPolicy() //队列满了，尝试和最早的竞争，也不会抛出异常
 *

线程生命周期(状态)

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态

public enum State {
// 新生,此时仅由 JVM 为其分配内存，并初始化其成员变量的值
    NEW,
// 调用了 start()方法之后，该线程处于运行Java 虚拟机会为其创建方法调用栈和程序计数器，等待调度运行
    RUNNABLE,
// 阻塞
    BLOCKED,
// 等待，死死地等
    WAITING,
// 超时等待
    TIMED_WAITING,
// 终止
    TERMINATED;
}

终止线程方法

除了正常退出外有三种方法可以结束线程

• 设置退出标志，使线程正常退出，也就是当run()方法完成后线程终止
• 使用interrupt()方法中断线程
• 使用stop方法强行终止线程(不推荐使用)

1.使用退出标志终止线程

最直接的方法就是设一个boolean类型的标志，并通过设置这个标志为true或false来控制while循环是否退出

public class ThreadSafe extends Thread {
    public volatile boolean exit = false; 
        public void run() { 
        while (!exit){
            //do something
        }
    } 
}

2.使用interrupt()方法中断当前线程
白嫖资料
使用interrupt()方法来中断线程有两种情况：

1. 线程处于阻塞状态当调用线程的interrupt()方法时，会抛出InterruptException异常。阻塞中的那个方法抛出这个异常，通过代码捕获该异常，然后break跳出循环状态，从而让我们有机会结束这个线程的执行。
2. 线程未处于阻塞状态，使用isInterrupted()判断线程的中断标志来退出循环。

代码演示:

//第一种情况
public class ThreadSafe extends Thread {
    public void run() { 
        while (true){
            try{
                    Thread.sleep(5*1000);//阻塞5妙
                }catch(InterruptedException e){
                    e.printStackTrace();
                    break;//捕获到异常之后，执行break跳出循环。
                }
        }
    } 
}

//第二种情况
public class ThreadSafe extends Thread {
    public void run() { 
        while (!isInterrupted()){
            //do something, but no throw InterruptedException
        }
    } 
}

3.使用stop方法终止线程

程序中可以直接使用thread.stop()来强行终止线程，但是stop方法是很危险的

不安全主要是：

thread.stop()调用之后，创建子线程的线程就会抛出ThreadDeatherror的错误，并且会释放子线程所持有的所有锁。一般任何进行加锁的代码块，都是为了保护数据的一致性，如果在调用thread.stop()后导致了该线程所持有的所有锁的突然释放(不可控制)，那么被保护数据就有可能呈现不一致性，其他线程在使用这些被破坏的数据时，有可能导致一些很奇怪的应用程序错误。

Java线程锁

乐观锁

白嫖资料
乐观锁是一种乐观思想，即认为读多写少，遇到并发写的可能性低，每次去拿数据的时候都认为 别人不会修改，所以不会上锁但是在更新的时候会判断一下在此期间别人有没有去更新这个数 据，采取在写时先读出当前版本号，然后加锁操作,如果失败则要重复读-比较-写的操作。

java 中的乐观锁基本都是通过 CAS 操作实现的，CAS 是一种更新的原子操作

悲观锁

悲观锁是就是悲观思想，即认为写多，遇到并发写的可能性高，每次去拿数据的时候都认为别人 会修改，所以每次在读写数据的时候都会上锁，这样别人想读写这个数据就会 block 直到拿到锁。

java中的悲观锁就是Synchronized

自旋锁

如果持有锁的线程能在很短时间内释放锁资源，那么那些等待竞争锁 的线程就不需要做内核态和用户态之间的切换进入阻塞挂起状态，它们只需要等一等（自旋）， 等持有锁的线程释放锁后即可立即获取锁，这样就避免用户线程和内核的切换的消耗

优缺点

自旋锁尽可能的减少线程的阻塞，

这对于锁的竞争不激烈，且占用锁时间非常短的代码块来 说性能能大幅度的提升，因为自旋的消耗会小于线程阻塞挂起再唤醒的操作的消耗，这些操作会 导致线程发生两次上下文切换！

但是如果锁的竞争激烈，或者持有锁的线程需要长时间占用锁执行同步块，这时候就不适合 使用自旋锁了，因为自旋锁在获取锁前一直都是占用 cpu 做无用功，占着 XX 不 XX，同时有大量 线程在竞争一个锁，会导致获取锁的时间很长，线程自旋的消耗大于线程阻塞挂起操作的消耗， 其它需要 cup 的线程又不能获取到 cpu，造成 cpu 的浪费。所以这种情况下我们要关闭自旋锁；

Synchronized同步锁

synchronized 它可以把任意一个非 NULL 的对象当作锁。他属于独占式的悲观锁，同时属于可重 入锁。

Synchronized 作用范围

白嫖资料

• 作用于方法时，锁住的是对象的实例(this)；
• 当作用于静态方法时，锁住的是Class实例，此静态方法锁相当于类的一个全局锁， 会锁所有调用该方法的线程
• synchronized 作用于一个对象实例时，锁住的是所有以该对象为锁的代码块。

lock锁

//lock锁通常使用可重入锁ReentrantLock
Lock lock = new ReentrantLock();

ReentantLock 继承接口 Lock 并实现了接口中定义的方法，他是一种可重入锁，除了能完 成 synchronized 所能完成的所有工作外，还提供了诸如可响应中断锁、可轮询锁请求、定时锁等 避免多线程死锁的方法

public class SaleTicketDemo02 {
    public static void main(String[] args) {
        // 并发：多线程操作同一个资源类, 把资源类丢入线程
        Ticket2 ticket = new Ticket2();
        // @FunctionalInterface 函数式接口，jdk1.8 lambda表达式 (参数)->{ 代码 }
        new Thread(()->{for (int i = 1; i < 40 ; i++)
        ticket.sale();},"A").start();
        new Thread(()->{for (int i = 1; i < 40 ; i++)
        ticket.sale();},"B").start();
        new Thread(()->{for (int i = 1; i < 40 ; i++)
        ticket.sale();},"C").start();
    }
}
// Lock三部曲
// 1、 new ReentrantLock();
// 2、 lock.lock(); // 加锁
// 3、 finally=> lock.unlock(); // 解锁
class Ticket2 {
    // 属性、方法
    private int number = 30;
    Lock lock = new ReentrantLock();
    
    public void sale(){
        lock.lock(); // 加锁
        try {
            // 业务代码
            if (number>0){
                System.out.println(Thread.currentThread().getName()+"卖出了"+
                (number--)+"票,剩余："+number);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock(); // 解锁
        }
    }
}

synchronized 和 lock锁的区别

• synchronized 是java内置的关键字，lock是一个java类

• synchronized 无法获取锁的状态，lock 可以判断是否获得了锁

• synchronized 会自动释放锁，lock不会自动释放锁，需要自己手动释放锁，如果不释放锁，会造成死锁

• synchronized 线程一（获得锁，然后锁阻塞了），线程二（等待，然后还是傻傻的等待），lock锁就不一定会等待下去

• synchronized 可重入锁，不可以被中断，非公平，lock 可重入锁，可判断锁，是否为公平锁，可以自行设置

• synchronized 适合少量的代码同步问题，lock适合大量的代码同步问题

公平锁与非公平锁

公平锁：十分公平：可以先来后到

非公平锁：十分不公平：可以插队 （默认）

读写锁

白嫖资料
为了提高性能，Java 提供了读写锁，在读的地方使用读锁，在写的地方使用写锁，灵活控制，

如果没有写锁的情况下，读是无阻塞的,在一定程度上提高了程序的执行效率。

读写锁分为读锁和写 锁，多个读锁不互斥，读锁与写锁互斥，这是由 jvm 自己控制的，你只要上好相应的锁即可。

读锁

如果你的代码只读数据，可以很多人同时读，但不能同时写，那就上读锁

写锁

如果你的代码修改数据，只能有一个人在写，且不能同时读取，那就上写锁。总之，读的时候上 读锁，写的时候上写锁！

// 加锁的
class MyCacheLock{
    private volatile Map<String,Object> map = new HashMap<>();
    // 读写锁： 更加细粒度的控制
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private Lock lock = new ReentrantLock();
    // 存，写入的时候，只希望同时只有一个线程写
    public void put(String key,Object value){
        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"写入"+key);
            map.put(key,value);
            System.out.println(Thread.currentThread().getName()+"写入OK");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.writeLock().unlock();
        }
    }
    // 取，读，所有人都可以读！
    public void get(String key){
        readWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"读取"+key);
            Object o = map.get(key);
            System.out.println(Thread.currentThread().getName()+"读取OK");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }
    }
}

白嫖资料

锁优化

减少锁持有时间

只用在有线程安全要求的程序上加锁

减小锁粒度

将大对象（这个对象可能会被很多线程访问），拆成小对象，大大增加并行度，降低锁竞争。

锁分离

最常见的锁分离就是读写锁 ReadWriteLock，根据功能进行分离成读锁和写锁，这样读读不互 斥，读写互斥，写写互斥，即保证了线程安全，又提高了性能，

锁粗化

要求每个线程持有锁的时间尽量短，即在使用完 公共资源后，应该立即释放锁。

但是，凡事都有一个度，如果对同一个锁不停的进行请求、同步 和释放，其本身也会消耗系统宝贵的资源，反而不利于性能的优化

锁消除

如果发现不可能被共享的对象，则可以消除这 些对象的锁操作

死锁

两个线程或两个以上线程都在等待对方执行完毕才能继续往下执行的时候就发生了死锁。结果就是这些线程都陷入了无限的等待中。

如何避免线程死锁?
只要破坏产生死锁的四个条件中的其中一个就可以了。
白嫖资料

• 破坏互斥条件：这个条件我们没有办法破坏，因为我们用锁本来就是想让他们互斥的（临界资源需要互斥访问）。
• 破坏请求与保持条件：一次性申请所有的资源。
• 破坏不剥夺条件：占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动释放它占有的资源。
• 破坏循环等待条件：靠按序申请资源来预防。按某一顺序申请资源，释放资源则反序释放

线程基本方法

线程相关的基本方法有 wait，notify，notifyAll，sleep，join，yield 等。

线程等待（wait）

调用该方法的线程进入 WAITING 状态，只有等待另外线程的通知或被中断才会返回，需要注意的是调用 wait()方法后，会释放对象的锁。

线程睡眠（sleep）

sleep 导致当前线程休眠，与 wait 方法不同的是 sleep 不会释放当前占有的锁,sleep(long)会导致线程进入 TIMED-WATING 状态，而 wait()方法会导致当前线程进入 WATING 状态

线程让步（yield）

yield 会使当前线程让出 CPU 执行时间片，与其他线程一起重新竞争 CPU 时间片。一般情况下，优先级高的线程有更大的可能性成功竞争得到 CPU 时间片

线程中断（interrupt ）

白嫖资料
中断一个线程，其本意是给这个线程一个通知信号，会影响这个线程内部的一个中断标识位。这个线程本身并不会因此而改变状态

Join 等待其他线程终止

在当前线程中调用一个线程的 join() 方法，则当前线程转为阻塞状态，直到另一个线程结束，当前线程再由阻塞状态变为就绪状态，等待 cpu 的宠幸。

为什么要用 join() 方法 ？

很多情况下，主线程生成并启动了子线程，需要用到子线程返回的结果，也就是需要主线程需要在子线程结束后再结束，这时候就要用到 join() 方法。

线程唤醒（notify）

唤醒在此对象监视器上等待的单个线程，如果所有线程都在此对象上等待，则会选择唤醒其中一个线程，选择是任意的，被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争。

其他方法：

• sleep()：强迫一个线程睡眠Ｎ毫秒。

• isAlive()： 判断一个线程是否存活。

• join()： 等待线程终止。

• activeCount()： 程序中活跃的线程数。

• enumerate()： 枚举程序中的线程。

• currentThread()： 得到当前线程。

• isDaemon()： 一个线程是否为守护线程。

• setDaemon()： 设置一个线程为守护线程。(用户线程和守护线程的区别在于，是否等待主线程依赖于主线程结束而结束)

• setName()： 为线程设置一个名称。

• wait()： 强迫一个线程等待。

• notify()： 通知一个线程继续运行。

• setPriority()： 设置一个线程的优先级。

• getPriority():：获得一个线程的优先级。

volatile与synchronized

volatile特点

• 保证可见性
• 不保证原子性

使用场景

• 对变量的写操作不依赖于当前值（比如 i++），或者说是单纯的变量赋值（boolean flag = true）
• 该变量没有包含在具有其他变量的不变式中，也就是说，不同的 volatile 变量之间，不 能互相依赖。只有在状态真正独立于程序内其他内容时才能使用 volatile

区别:

• 修饰对象不同，volatile用于修饰变量，synchronized用与对语句和方法加锁；
• 各自作用不同，volatile保证数据的可见性和有序性，但它并不能保证数据的原子性，synchronized可以保证原子性；
• volatile不会造成线程堵塞，而synchronized会造成线程堵塞；

常用的辅助类

CountDownLatch（线程计数器 ）

可以实现类似计数器的功能。比如有 一个任务 A，它要等待其他 4 个任务执行完毕之后才能执行，此时就可以利用 CountDownLatch 来实现这种功能了

    public static void main(String[] args) throws InterruptedException {
// 总数是6，必须要执行任务的时候，再使用！
    CountDownLatch countDownLatch = new CountDownLatch(6);
    for (int i = 1; i <=6 ; i++) {
        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+" Go out");
            countDownLatch.countDown(); // 数量-1
        },String.valueOf(i)).start();
    }
    countDownLatch.await(); // 等待计数器归零，然后再向下执行
    System.out.println("Close Door");
}

CyclicBarrier（回环栅栏-等待至 barrier 状态再全部同时执行）

白嫖资料
通过它可以实现让一组线程等待至某个状态之后再全部同时执行。叫做回环 是因为当所有等待线程都被释放以后，CyclicBarrier 可以被重用。

public static void main(String[] args) {
    /**
     * 集齐7颗龙珠召唤神龙
     */
    // 召唤龙珠的线程
    CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
        System.out.println("召唤神龙成功！");
    });
    for (int i = 1; i <=8 ; i++) {
        final int temp = i;
        // lambda能操作到 i 吗   
        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"收集"+temp+"个龙珠");
            try {
                cyclicBarrier.await(); // 等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

Semaphore（信号量-控制同时访问的线程个数）

Semaphore 可以控制同时访问的线程个数，通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。

    public static void main(String[] args) {
// 线程数量：停车位! 限流！
    Semaphore semaphore = new Semaphore(3);
    for (int i = 1; i <=6 ; i++) {
        new Thread(()->{
// acquire() 得到
            try {
                semaphore.acquire();
                System.out.println(Thread.currentThread().getName()+"抢到车位");
                        TimeUnit.SECONDS.sleep(2);
                System.out.println(Thread.currentThread().getName()+"离开车位");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                semaphore.release(); // release() 释放
            }
        },String.valueOf(i)).start();
    }
}

最后，祝大家早日学有所成，拿到满意offer，快速升职加薪，走上人生巅峰。 可以的话请给我一个三连支持一下我哟，我们下期再见

白嫖资料