基础问题-优快云博客

本文链接：https://blog.youkuaiyun.com/HreathSkill/article/details/105099276

本文详细介绍了Java中多线程的实现方式，包括线程的创建、线程池的使用、线程间的同步机制，以及常见集合类的线程安全性。探讨了ArrayList与Vector、Array与ArrayList的区别，Queue的操作方法，线程安全的集合类，迭代器的使用，线程的生命周期，线程池的状态，线程同步与死锁的预防。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

26.如何实现数组和List之间的转换*

public class ArrayToList {

public static void main(String[] args) {
	
	//数组转list
	String[] str=new String[] {"hello","world"};
	//方式一：使用for循环把数组元素加进list
	List<String> list=new ArrayList<String>();
	for (String string : str) {
		list.add(string);
	}
	System.out.println(list);
	
	//方式二：
	List<String> list2=new ArrayList<String>(Arrays.asList(str));
	System.out.println(list2);
	
	//方式三：
	//同方法二一样使用了asList()方法。这不是最好的，
	//因为asList()返回的列表的大小是固定的。
	//事实上，返回的列表不是java.util.ArrayList类，而是定义在java.util.Arrays中一个私有静态类java.util.Arrays.ArrayList
	//我们知道ArrayList的实现本质上是一个数组，而asList()返回的列表是由原始数组支持的固定大小的列表。
	//这种情况下，如果添加或删除列表中的元素，程序会抛出异常UnsupportedOperationException。
	//java.util.Arrays.ArrayList类具有 set()，get()，contains()等方法，但是不具有添加add()或删除remove()方法,所以调用add()方法会报错。
	List<String> list3 = Arrays.asList(str);
	//list3.remove(1);
	//boolean contains = list3.contains("s");
	//System.out.println(contains);
	System.out.println(list3);
	
	//方式四：使用Collections.addAll()
	List<String> list4=new ArrayList<String>(str.length);
	Collections.addAll(list4, str);
	System.out.println(list4);
	
	//方式五：使用Stream中的Collector收集器
	//转换后的List 属于 java.util.ArrayList 能进行正常的增删查操作
	List<String> list5=Stream.of(str).collect(Collectors.toList());
	System.out.println(list5);
}

}

List转数组

package listtoArray;

import java.util.ArrayList;
import java.util.List;

public class ListToArray {

public static void main(String[] args) {
//list转数组
List list=new ArrayList();
list.add(“hello”);
list.add(“world”);

	//方式一：使用for循环
	String[] str1=new String[list.size()];
	for(int i=0;i<list.size();i++) {
		str1[i]=list.get(i);
	}
	for (String string : str1) {
		System.out.println(string);
	}
	
	//方式二：使用toArray()方法
	//list.toArray(T[]  a); 将list转化为你所需要类型的数组
	String[] str2=list.toArray(new String[list.size()]);
	for (String string : str2) {
		System.out.println(string);
	}
	
	//错误方式：易错   list.toArray()返回的是Object[]数组，怎么可以转型为String
	//ArrayList<String> list3=new ArrayList<String>();
	//String strings[]=(String [])list.toArray();
}

}

27.ArrayList,Vector主要区别为以下几点：

（1）同步性：Vector是线程安全的，用synchronized实现线程安全，而ArrayList是线程不安全的，如果只有一个线程会访问到集合，那最好使用ArrayList，因为它不考虑线程安全，效率会高些；如果有多个线程会访问到集合，那最好是使用Vector，因为不需要我们再去考虑和编写线程安全的代码。

（2）数据容量增长：二者都有一个初始容量大小，采用线性连续存储空间，当存储的元素的个数超过了容量时，就需要增加二者的存储空间，Vector增长原来的一倍，ArrayList增加原来的0.5倍。

Vector多了一个public Vector(int initialCapacity, int capacityIncrement)构造器，可以设置容量增长，ArrayList是没有的。

如过在集合中使用数据量比较大的数据，用vector有一定的优势

28.Array 和 ArrayList 有何区别？

答：Array 与 ArrayList 都是用来存储数据的集合。ArrayList 底层是使用数组实现的，但是ArrayList对数组进行了封装和功能扩展

29.Queue 中 poll()和 remove()有什么区别？

队列是一个典型的先进先出（FIFO）的容器。即从容器的一端放入事物，从另一端取出，并且事物放入容器的顺序与取出的顺序是相同的。
队列的两种实现方式：

1、offer()和add()的区别

add()和offer()都是向队列中添加一个元素。但是如果想在一个满的队列中加入一个新元素，调用 add() 方法就会抛出一个 unchecked 异常，而调用 offer() 方法会返回 false。可以据此在程序中进行有效的判断！
2、peek()和element()的区别

peek()和element()都将在不移除的情况下返回队头，但是peek()方法在队列为空时返回null，调用element()方法会抛出NoSuchElementException异常。
3、poll()和remove()的区别

poll()和remove()都将移除并且返回对头，但是在poll()在队列为空时返回null，而remove()会抛出NoSuchElementException异常。
30.Java哪些集合类是线程安全的？

Vector：就比Arraylist多了个同步化机制（线程安全）。

Hashtable：就比Hashmap多了个线程安全。

ConcurrentHashMap:是一种高效但是线程安全的集合。

Stack：栈，也是线程安全的，继承于Vector。

31.迭代器 Iterator 是什么？

在Java中，有很多的数据容器，对于这些的操作有很多的共性。Java采用了迭代器来为各种容器提供了公共的操作接口。这样使得对容器的遍历操作与其具体的底层实现相隔离，达到解耦的效果。

在这里插入图片描述

33.Iterator 和 ListIterator 有什么区别？

ListIterator

上面可以看到，Iterator只提供了删除元素的方法remove，如果我们想要在遍历的时候添加元素怎么办？

ListIterator接口继承了Iterator接口，它允许程序员按照任一方向遍历列表，迭代期间修改列表，并获得迭代器在列表中的当前位置。

ListIterator接口定义了下面几个方法：

在这里插入图片描述

34.怎么确保一个集合不能被修改？

将参数中的List返回一个不可修改的List

Collections的静态方法unmodifiableList可以达到目的。方法原型为：public static List unmodifiableList(List<? extends T> list);用法也很简单，传入一个List实例la，返回这个list的只读视图lb，类型依然是List。之后对lb进行add、remove等改变其内容的操作将导致编译不通过。

https://blog.youkuaiyun.com/cilen/article/details/7744969

Student1类，仅对外提供的getCourses()方法，而没有setCourses()方法，而且

通过getCourses()方法获得的courses是“只读的”，如果你试图向其添加一个新课程，则

抛出java.lang.UnsupportedOperationException。你必须通过Student1.addCourse()来

向特定的Student1对象添加一个新课程。就好像，你必须让顾客自己向购物车里放食物，

而不能在顾客毫不知情下，偷偷向其购物车里放食物。

35.并行和并发有什么区别？

答：

并发在单核和多核都可存在，就是同一时间有多个可以执行的进程。但是在单核中同一时刻只有一个进程获得CPU,虽然宏观上你认为多个进程都在进行
并行是指同一时间多个进程在微观上都在真正的执行，这就只有在多核的情况下了

36.线程和进程的区别？

答：

线程：是程序执行流的最小单元，是系统独立调度和分配CPU（独立运行）的基本单位
进程：是资源分配的基本单位。一个进程包括多个线程

区别：地址空间、资源拥有

线程与资源分配无关，它属于某一个进程，并与进程内的其他线程一起共享进程的资源
每个进程都有自己一套独立的资源（数据），供其内的所有线程共享
不论是大小，开销线程要更“轻量级”
一个进程内的线程通信比进程之间的通信更快速，有效。（因为共享变量）

37.守护线程是什么？

daemon thread

如果 JVM 中没有一个正在运行的非守护线程，这个时候，JVM 会退出。换句话说，守护线程拥有自动结束自己生命周期的特性，而非守护线程不具备这个特点。

JVM 中的垃圾回收线程就是典型的守护线程，如果说不具备该特性，会发生什么呢？

当 JVM 要退出时，由于垃圾回收线程还在运行着，导致程序无法退出，这就很尴尬了！！！由此可见，守护线程的重要性了。

通常来说，守护线程经常被用来执行一些后台任务，但是呢，你又希望在程序退出时，或者说 JVM 退出时，线程能够自动关闭，此时，守护线程是你的首选。

38.创建线程有哪几种方式？

1.继承Thread类（真正意义上的线程类），是Runnable接口的实现。

2.实现Runnable接口，并重写里面的run方法

3.应用程序可以使用Executor框架来创建线程池。Executor框架是juc里提供的线程池的实现。

4.实现Callable接口通过FutureTask包装器来创建Thread线程

39.说一下 runnable 和 callable 有什么区别？

答：runnable 没有返回值，callable 可以拿到有返回值，callable 可以看作是 runnable 的补充。

40.线程有哪些状态？

答：创建、就绪、运行、阻塞、死亡

41.sleep() 和 wait() 有什么区别？

sleep()不释放同步锁,wait()释放同步锁. 这两个方法来自不同的类分别是Thread和Object.wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在
任何地方使用

43.线程的 run()和 start()有什么区别？

run()方法，是同步执行；通过start()调用run()，是异步执行。run()相当于线程的任务处理逻辑的入口方法，它由Java虚拟机在运行相应线程时直接调用，而不是由应用代码进行调用。

而start()的作用是启动相应的线程。启动一个线程实际是请求Java虚拟机运行相应的线程，而这个线程何时能够运行是由线程调度器决定的。start()调用结束并不表示相应线程已经开始运行，这个线程可能稍后运行，也可能永远也不会运行。

44.创建线程池有哪几种方式？

newCachedThreadPool()：它是一种用来处理大量短时间工作任务的线程池，具有几个鲜明特点：它会试图缓存线程并重用，当无缓存线程可用时，就会创建新的工作线程；如果线程闲置的时间超过 60 秒，则被终止并移出缓存；长时间闲置时，这种线程池，不会消耗什么资源。其内部使用 SynchronousQueue 作为工作队列；
newFixedThreadPool(int nThreads)：重用指定数目（nThreads）的线程，其背后使用的是无界的工作队列，任何时候最多有 nThreads 个工作线程是活动的。这意味着，如果任务数量超过了活动队列数目，将在工作队列中等待空闲线程出现；如果有工作线程退出，将会有新的工作线程被创建，以补足指定的数目 nThreads；
newScheduledThreadPool(int corePoolSize)：和newSingleThreadScheduledExecutor()类似，创建的是个 ScheduledExecutorService，可以进行定时或周期性的工作调度，区别在于单一工作线程还是多个工作线程；
newSingleThreadExecutor()：它的特点在于工作线程数目被限制为 1，操作一个无界的工作队列，所以它保证了所有任务的都是被顺序执行，最多会有一个任务处于活动状态，并且不允许使用者改动线程池实例，因此可以避免其改变线程数目；
newSingleThreadScheduledExecutor()：创建单线程池，返回 ScheduledExecutorService，可以进行定时或周期性的工作调度；
newWorkStealingPool(int parallelism)：这是一个经常被人忽略的线程池，Java 8 才加入这个创建方法，其内部会构建ForkJoinPool，利用Work-Stealing算法，并行地处理任务，不保证处理顺序；
ThreadPoolExecutor()：是最原始的线程池创建，上面1-3创建方式都是对ThreadPoolExecutor的封装。

45.线程池都有哪些状态？

答：

RUNNING：这是最正常的状态，接受新的任务，处理等待队列中的任务。
SHUTDOWN：不接受新的任务提交，但是会继续处理等待队列中的任务。
STOP：不接受新的任务提交，不再处理等待队列中的任务，中断正在执行任务的线程。
TIDYING：所有的任务都销毁了，workCount 为 0，线程池的状态在转换为 TIDYING 状态时，会执行钩子方法 terminated()。
TERMINATED：线程池彻底终止,terminated()方法结束后，线程池的状态就会变成这个。

46.线程池中 submit()和 execute()方法有什么区别？

execute() 参数 Runnable ；submit() 参数 (Runnable) 或 (Runnable 和结果 T) 或 (Callable)
execute() 没有返回值；而 submit() 有返回值
submit() 的返回值 Future 调用get方法时，可以捕获处理异常

47.在 java 程序中怎么保证多线程的运行安全？

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

原子性：一个或者多个操作在 CPU 执行的过程中不被中断的特性
可见性：一个线程对共享变量的修改，另外一个线程能够立刻看到
有序性：程序执行的顺序按照代码的先后顺序执行

导致原因：

缓存导致的可见性问题
线程切换带来的原子性问题
编译优化带来的有序性问题

解决办法：

synchronized是java中的一个关键字，也就是说是java内置的一个特性。当一个线程访问一个被synchronized修饰的代码块，会自动获取对应的一个锁，并在执行该代码块时，其他线程想访问这个代码块，会一直处于等待状态，自有等该线程释放锁后，其他线程进行资源竞争，竞争获取到锁的线程才能访问该代码块。

采用synchronized关键字来实现同步，会导致如果存在多个线程想执行该代码块，而当前获取到锁的线程又没有释放锁

ReentranLock是Lock的唯一实现类。下面简单介绍一下ReentranLock与synchronized的区别：

Synchronized是一个同步锁。当一个线程A访问synchronized修饰的代码块时，线程A就会获取该代码块的锁，如果这时存在其他线程范围该代码块时，将会阻塞，但是不影响这些线程访问其他非同步代码块。
ReentranLock是可重入锁。由构造方法可知，该锁支持两种锁模式，公平锁和非公平锁。默认是非公平的。

公平锁：当线程A获取访问该对象，获取到锁后，此时内部存在一个计数器num+1，其他线程想访问该对象，就会进行排队等待(等待队列最前一个线程处于待唤醒状态)，直到线程A释放锁(num = 0)，此时会唤醒处于待唤醒状态的线程进行获取锁的操作，一直循环。如果线程A再次尝试获取该对象锁是，会检查该对象锁释放已经被占用，如果被占用，会做一次是否为当前线程占用锁的判断，如果是内部计数器num+1，并且不需要进入等待队列，而是直接回去当前锁。

非公平锁：当线程A在释放锁后，等待对象的线程会进行资源竞争，竞争成功的线程将获取该锁，其他线程继续睡眠。

公平锁是严格的以FIFO的方式进行锁的竞争，但是非公平锁是无序的锁竞争，刚释放锁的线程很大程度上能比较快的获取到锁，队列中的线程只能等待，所以非公平锁可能会有“饥饿”的问题。但是重复的锁获取能减小线程之间的切换，而公平锁则是严格的线程切换，这样对操作系统的影响是比较大的，所以非公平锁的吞吐量是大于公平锁的，这也是为什么JDK将非公平锁作为默认的实现

线程释放synchronized修饰的代码块锁的方式有两种：

该线程执行完对应代码块，自动释放锁。
在执行该代码块是发生了异常，JVM会自动释放锁。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PGTvPZy6-1585126781216)(C:\Users\rzy19\Desktop\comparelock.png)]

JDK Atomic开头的原子类、synchronized、LOCK，可以解决原子性问题
synchronized、volatile、LOCK，可以解决可见性问题
Happens-Before 规则可以解决有序性问题

使用安全类，比如 Java. util. concurrent 下的类。

49.什么是死锁？

线程死锁是指由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行。当线程进入对象的synchronized代码块时，便占有了资源，直到它退出该代码块或者调用wait方法，才释放资源，在此期间，其他线程将不能进入该代码块。当线程互相持有对方所需要的资源时，会互相等待对方释放资源，如果线程都不主动释放所占有的资源，将产生死锁。

当然死锁的产生是必须要满足一些特定条件的：
1.互斥条件（资源）：进程对于所分配到的资源具有排它性，即一个资源只能被一个进程占用，直到被该进程释放不能共享

3.不剥夺条件（资源）：任何一个资源在没被该进程释放之前，任何其他进程都无法对他剥夺占用

2.请求和保持条件(进程)：一个进程因请求被占用资源而发生阻塞时，对已获得的资源保持不放。

4.循环等待条件(进程)：当发生死锁时，所等待的进程必定会形成一个环路（类似于死循环），造成永久阻塞。

50.怎么防止死锁？

(1) 死锁预防：破坏导致死锁必要条件中的任意一个就可以预防死锁。例如，要求用户申请资源时一次性申请所需要的全部资源，这就破坏了保持和等待条件；将资源分层，得到上一层资源后，才能够申请下一层资源，它破坏了环路等待条件。预防通常会降低系统的效率。

(2) 死锁避免：避免是指进程在每次申请资源时判断这些操作是否安全，例如，使用银行家算法。死锁避免算法的执行会增加系统的开销。

(3) 死锁检测：死锁预防和避免都是事前措施，而死锁的检测则是判断系统是否处于死锁状态，如果是，则执行死锁解除策略。

(4) 死锁解除：这是与死锁检测结合使用的，它使用的方式就是剥夺。即将某进程所拥有的资源强行收回，分配给其他的进程。

![img](C:\Users\rzy19\Desktop\1222507-20190603205436977-1451348357.p

尽量使用 tryLock(long timeout, TimeUnit unit)的方法(ReentrantLock、ReentrantReadWriteLock)，设置超时时间，超时可以退出防止死锁。
尽量使用 Java. util. concurrent 并发类代替自己手写锁。
尽量降低锁的使用粒度，尽量不要几个功能用同一把锁。
尽量减少同步的代码块。

51.ThreadLocal 是什么？有哪些使用场景？

ThreadLocal是线程Thread中属性threadLocals的管理者。

https://blog.youkuaiyun.com/zzg1229059735/article/details/82715741

其实我们无意间已经时时刻刻在使用ThreadLocal提供的便利，如果说多数据源的切换你比较陌生，那么spring提供的声明式事务就再熟悉不过了，我们在研发过程中无时无刻不在使用，而spring声明式事务的重要实现基础就是ThreadLocal，只不过大家没有去深入研究spring声明式事务的实现机制。后面有机会我会给大家介绍spring声明式事务的原理及实现机制。
————————————————

52.说一下 synchronized 底层实现原理？

答：synchronized 是由一对 monitorenter/monitorexit 指令实现的，monitor 对象是同步的基本实现单元。在 Java 6 之前，monitor 的实现完全是依靠操作系统内部的互斥锁，因为需要进行用户态到内核态的切换，所以同步操作是一个无差别的重量级操作，性能也很低。但在 Java 6 的时候，Java 虚拟机对此进行了大刀阔斧地改进，提供了三种不同的 monitor 实现，也就是常说的三种不同的锁：偏向锁（Biased Locking）、轻量级锁和重量级锁，大大改进了其性能。代码块的同步是利用monitorenter和monitorexit这两个字节码指令。它们分别位于同步代码块的开始和结束位置。当jvm执行到monitorenter指令时，当前线程试图获取monitor对象的所有权，如果未加锁或者已经被当前线程所持有，就把锁的计数器+1；当执行monitorexit指令时，锁计数器-1；当锁计数器为0时，该锁就被释放了。如果获取monitor对象失败，该线程则会进入阻塞状态，直到其他线程释放锁。

53.volatile和synchronized的区别

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

54.synchronized 和 Lock 有什么区别？
在这里插入图片描述

synchronized 自动释放

55.synchronized 和 ReentrantLock 区别是什么？

1.1jvm 2类

2.1自动释放锁 2手动释放

3.synchronized不可中断，除非抛出异常或者正常运行完成 ReentrantLock 可中断

4.synchronized非公平锁 ReentrantLock两者都可以，默认非公平锁，构造方法可以传入boolean值，true为公平锁，false为非公平锁

5.ReentrantLock 只适用于代码块锁，而 synchronized 可用于修饰方法、代码块等。

6.ReentrantLock可以用condition来实现分组唤醒需要唤醒的线程们，可以精确唤醒，而不是像synchronized要么随机唤醒一个线程要么唤醒全部线程。synchronized没有

56.说一下 atomic 的原理？

可以比较便利的实现一些简单的数据同步通过CAScompareandswap

compareAndSwapInt()方法的第一个参数（var1）是当前的对象，就是代码示例中的count。此时它的值为0（期望值）。第二个值（var2）是传递的valueOffset值，它的值为12。第三个参数（var4）就为常量1。方法中的变量参数（var5）是根据参数一和参数二valueOffset，调用底层getIntVolatile方法得到的值，此时它的值为0 。compareAndSwapInt()想要达到的目标是对于count这个对象，如果当前的期望值var1里的value跟底层的返回的值（var5）相同的话，那么把它更新成var5+var4这个值。不同的话重新循环取期望值（var5）直至当前值与期望值相同才做更新。compareAndSwap方法的核心也就是我们通常所说的CAS。
乐观锁保证原子性，通过自旋保证当次修改的最终修改成功，通过**降低锁粒度（多段锁）**增加并发性能。

前的对象，就是代码示例中的count。此时它的值为0（期望值）。第二个值（var2）是传递的valueOffset值，它的值为12。第三个参数（var4）就为常量1。方法中的变量参数（var5）是根据参数一和参数二valueOffset，调用底层getIntVolatile方法得到的值，此时它的值为0 。compareAndSwapInt()想要达到的目标是对于count这个对象，如果当前的期望值var1里的value跟底层的返回的值（var5）相同的话，那么把它更新成var5+var4这个值。不同的话重新循环取期望值（var5）直至当前值与期望值相同才做更新。compareAndSwap方法的核心也就是我们通常所说的CAS。
乐观锁保证原子性，通过自旋保证当次修改的最终修改成功，通过**降低锁粒度（多段锁）**增加并发性能。