java面试：多线程

1、多线程

​ 同步：发送一个指令需要等待返回才能发送下一条（完成一件事才能做下一件）。

​ 异步：发送一个请求不需要等待返回，随时可以再发下一条（一次进行多个事件）

线程不安全根本原因是异步，对一个资源多个线程同时操作。

1、什么是线程安全和线程不安全？

​ 压力测试或并发测试，会经常遇到此问题。

举例：假设售票系统有100张票，若线程不安全，A和B同时买了一张票后显示还有999张票，这是错的，应该只有998张票。

线程安全：

​ 安全指多个线程在执行同一段代码的时候采用加锁机制，使每次的执行结果和单线程执行的结构都一样。

线程不安全：

​ 指不提供加锁机制保护，有可能会出现多个线程先后更改数据造成所得的数据是脏数据。

2、引起线程安全问题的原因：

​ 1、线程安全问题都是有全局变量及静态变量引起的。

​ 若每个线程中全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的。

​ 若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。

​ 2、解决多线程并发访问资源安全问题的方法：

​ （1）synchronize（只给一个线程执行，完成后才到下一个线程）

​ 用来控制线程同步，保证我们的线程在多线程环境下，不被多个线程同时执行，确保数据完整性。使用方法加在方法上。

​ （2）lock

​ lock的引入让锁有了可操作性，是指我们在需要的时候手动获取锁和释放锁。

3、并发和并行有什么区别？

​ 你吃饭到一半，电话来了，你一直吃完才去接，说明你不支持并发也不支持并行。

​ 你吃饭迟到一半，电话来了，你停下来接电话，接完后继续吃饭，说明你支持并发。

​ 你吃饭迟到一半，电话来了，你一边打电话一半吃饭，说明你支持并行。

并发：有处理多个任务的能力，不一定要同时进行。同一实体上多个事件。

并行：有同时处理多个任务的能力。不同实体上多个事件。

4、线程和进程的区别？

​ 1、进程是程序运行和资源分配的基本单位。

​ 2、进程拥有独立的内存单元，而多个线程共享内存资源。

​ 3、一个进程可以包含多个线程。

5、守护线程是什么？

​ 守护线程（如：GC垃圾回收线程）是个服务线程，服务其他线程（如：用户线程即用户编写的线程）。

6、创建线程有哪几种方式？

​ 1、继承Thread类

​ 继承Thread类，重写run（）方法。通过start（）方法启动。

​ 2、实现Runnable接口

​ 定义Runnable接口的实现类，重run（）方法，调用start（）启动线程。

​ 3、通过Callable和Future创建线程

​ Callable和Runnable很类似，主要区别在于Callable能返回运行结果，能抛出异常。

​ 执行Callable方式，需要Future的实现类的支持，用于接收运算结果。FutureTask是Future接口的实现类。

public class TestCallable {

    public static void main(String[] args) {
        ThreadDemo td = new ThreadDemo();

        //1.执行 Callable 方式，需要 FutureTask 实现类的支持，用于接收运算结果。
        //参数里面放一个Callable的对象
        FutureTask<Integer> result = new FutureTask<>(td);

        new Thread(result).start();

        //2.接收线程运算后的结果
        try {
            Integer sum = result.get();  //FutureTask 可用于 闭锁 类似于CountDownLatch的作用，在所有的线程没有执行完成之后这里是不会执行的
            System.out.println(sum);
            System.out.println("------------------------------------");
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }

}

class ThreadDemo implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        int sum = 0;

        for (int i = 0; i <= 100000; i++) {
            sum += i;
        }

        return sum;
    }

}

7、Runnable和Callable有什么区别？

​ 1、Runnbale接run（）方法返回值void，只是去实现没有返回。

​ 2、Callable能返回结果，抛出异常。

8、线程有哪些状态？

​

​ 1、创建状态

​ 继承Thread类获实现Runnable得到线程类，new一个实例，进入初始化状态。

​ 2、就绪状态

​ 调用该对象的start（）方法。该线程位于线程池中，等待被线程调度选中，获取cpu使用权。

​ 3、运行状态

​ 线程获得了cpu时间片，执行程序代码。

​ 4、阻塞状态

​ 指线程因某种原因放弃了cpu使用权，暂时停止运行。

​ 5、死亡状态

​ 线程run()、main()方法结束，或因一场退出run()方法。

9、sleep()和wait()有什么区别？

​ 1、sleep()：是线程类（Thread）静态方法，让线程进入睡眠状态，结束后进入就绪状态和其他线程竞争cpu执行时间。

​ 2、wait()：wait()是Object类的方法。让它进入到对象相关的等待池，同时释放对象的机锁，通过notify()，notifyAll()方法唤醒等待的线程。

10、notify()和notifyAll()有什么区别？

​ 1、调用notifyAll()方法唤醒所有wait线程，notify()方法值随机唤醒一个wait线程。唤醒后进入对象锁池中竞争对象锁。

​ 2、优先级高的线程竞争获得对象锁概率大。没有竞争到的留在锁池，只有再次调用wait()才能进入等待池。竞争到对象锁的线程则继续往下执行，直到执行完synchronize代码块，它会释放该对象锁。

11、线程run()方法和start()方法有什么区别？

​ 每个线程通过特定的run()方法完成操作，成为线程体。

​ start()方法用来启动线程。

12、创建线程池有哪几种方式？

​ 1、newFixedThreadPool(int nThreads)：固定线程池

​ 创建固定长度的线程池，每当提交一个任务就创建一个线程，知道达到线程池的最大数量，这是线程规模将不再变化，当线程发生为预期的错误而结束时，线程池会补充一个新的线程。

/**
 * @author fangshixiang@vipkid.com.cn
 * @description
 * @date 2018-11-04 10:13
 */
public class Main {

    //创建一个固定线程池
    private static ExecutorService executor = Executors.newFixedThreadPool(1);

    //向kafka里推送消费
    public static void push2Kafka(Object msg) {
        executor.execute(() -> {
            try {
                //模拟 占用的内存大小
                Byte[] bytes = new Byte[1024 * 1000 * 1000];
                System.out.println(Thread.currentThread().getName() + "-->任务放到线程池:" + msg);
                TimeUnit.MINUTES.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
    }

    public static void main(String[] args) {

        //模拟高并发环境下  一直向线程池里面不停的塞任务
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            System.out.println("塞任务start..." + i);
            push2Kafka(i);
            System.out.println("塞任务end..." + i);
        }

    }
}

​ 2、newCachedThreadPool()：缓存线程池

​ 创建一个缓存的线程池，当线程池规模超过处理需求，将自动回收空闲线程，需求增加是自动添加新线程，不存在任何限制。

​ 3、newSingleThreadExecutor()：单线程执行

​ 单线程的Executor，创建单个线程执行任务，这个线程结束，会创建新的来代替它。

​ 4、newScheduledThreadPool（intcorePoolSize)

​ 创建固定长度线程池，且延迟或定时的方式执行任务。

13、线程池包含哪些状态？

1、RUNNING：

​ 线程池一旦创建就处于这个状态，能接收新任务，对已排队任务进行处理。

2、SHUTDOWN：

​ 调用shutdown()方法，线程有running转变为shutdown，不接收任务，但能处理已排队任务。

3、STOP：

​ 调用shutdownNow()方法，线程池有（running或shutdown）转变为stop状态。不接收新任务，不处理已排队任务。

4、TIDYING：

​ 1、SHUTDOWN状态下，任务数为0，任务终止，线程池转变为TIDYING状态。

​ 2、SHUTDOWN状态，任务队列为空，线程池转变为TIDYING 状态

​ 3、STOP状态，任务为空。

5、TERMINATED:

​ terminated状态下线程彻底终止。

14、java中怎么保证多线程的运行安全？

​ 线程的安全性问题体现在：

​ 1、原子性：一个或多个操作cpu执行过程中不被中断的特性。（atomic、aynchronized、lock）

​ 2、可见性：一个线程对共享变量的修改。（synchronized、volatitle、lock）

​ 3、有序性：程序执行的顺序按照代码的先后顺序执行。（happers-before原则）

15、什么是死锁？

​ 指两个或两个以上进程竞争资源造成的一种阻塞现象。

16、怎么防止死锁？

​ 死锁的四个必要条件：

​ 1、互斥条件：进程分配到的资源不允许其他进程访问，若其他进程访问资源，只能等待，直至占有该资源的进程使用完成。

​ 2、请求和保持条件：进程获取资源后，又对其他资源发出请求，但该资源可能被其他进程占有，此事请求阻塞，但又对自己获得的资源保持不放。

​ 3、不可剥夺条件：已获得的资源，不可被剥夺。

​ 4、环路等待条件：死锁后，若干进程之间形成一种头尾相接的循环等待资源关系。

只要上述条件之一不满足就不会发生死锁。

17、ThreadLocal是什么？有哪些使用场景？

​ ThreadLocal是线程本地存储，在每个线程中都创建了一个ThreadLocalMap对象，每个线程可以访问自己内部ThreadLocalMap对象内的value。能避免资源在多线程键共享。

​

​ 使用场景：经典的场景是为每个线程分配一个 JDBC 连接 Connection。这样就能保证每个线程都在各自的 Connection 上进行数据库的操作。还有 session 管理等问题

public class TestThreadLocal {

    //线程本地存储变量
    private static final ThreadLocal<Integer> THREAD_LOCAL_NUM = new ThreadLocal<Integer>() {
        @Override
        protected Integer initialValue() {
            return 0;
        }
    };

    public static void main(String[] args) {
        for (int i = 0; i <3; i++) {//启动三个线程
            Thread t = new Thread() {
                @Override
                public void run() {
                    add10ByThreadLocal();
                }
            };
            t.start();
        }
    }

    /**
     * 线程本地存储变量加 5
     */
    private static void add10ByThreadLocal() {
        for (int i = 0; i <5; i++) {
            Integer n = THREAD_LOCAL_NUM.get();
            n += 1;
            THREAD_LOCAL_NUM.set(n);
            System.out.println(Thread.currentThread().getName() + " : ThreadLocal num=" + n);
        }
    }

}

打印结果：启动了 3 个线程，每个线程最后都打印到 "ThreadLocal num=5"，而不是 num 一直在累加直到值等于 15
Thread-0 : ThreadLocal num=1
Thread-1 : ThreadLocal num=1
Thread-0 : ThreadLocal num=2
Thread-0 : ThreadLocal num=3
Thread-1 : ThreadLocal num=2
Thread-2 : ThreadLocal num=1
Thread-0 : ThreadLocal num=4
Thread-2 : ThreadLocal num=2
Thread-1 : ThreadLocal num=3
Thread-1 : ThreadLocal num=4
Thread-2 : ThreadLocal num=3
Thread-0 : ThreadLocal num=5
Thread-2 : ThreadLocal num=4
Thread-2 : ThreadLocal num=5
Thread-1 : ThreadLocal num=5

18、说一下synchronized底层原理？

​ synchronized可以保证方法或者代码块在运行时，同一时刻只有一个方法可以进入临界区。保证共享变量的内存可见性。

java中每一个对象都可以作为锁，这是synchronized实现同步的基础：

• 普通同步方法，锁是当前实例对象
• 静态同步方法，锁是当前类的class对象
• 同步方法块，锁是括号里面的对象

19、synchronized和volatile的区别是什么？

​ volatile是一个很老的关键字，jdk诞生时它就有了。作用是内存可见性和防止指令重排序。

• volatile本质是告诉jvm当前变量在寄存器（工作内存）中的值不确定，需要从主存中读取。synchronized是锁当前变量，只有当前线程可以访问该变量。
• volatile仅能使用在变量级别，synchronized则可以使用在变量、方法和类。
• volatile实现修改可见性，但不能保证原子性。而synchronized可以修改可见性和原子性。
• volatile不会造成线程阻塞，synchronized可能会造成线程阻塞。
• volatile标记变量不会被编译器优化，synchronized标记变量可以被编译器优化。

20、synchronized和Lock有什么区别？

​ 1、synchronized是java内置关键字，在jvm层面，lock是个java类。

​ 2、synchronized无法判断是否获取锁的状态，lock可以判断是否获取锁；

​ 3、synchronized自动释放锁，lock手动释放锁。

原文地址:https://blog.csdn.net/sufu1065/article/details/88051083