JAVA笔试题之集合数和多线程
一. 阐述下对于常用的集合数的理解。
答案通过百度百科整理而来，不保证百分百正确。
简述：
集合类是Java数据结构的实现。Java的集合类是java.util包中的重要内容，它允许以各种方式将元素分组，并定义了各种使这些元素更容易操作的方法。
集合类是用来存放某类对象的。集合类有一个共同特点，就是它们只容纳对象（实际上是对象名，即指向地址的指针）。这一点和数组不同，数组可以容纳对象和简单数据，Java集合不能存放基本数据类型数据，而只能存放对象的引用。如果在集合类中既想使用简单数据类型，又想利用集合类的灵活性，就可以把简单数据类型数据变成该数据类型类的对象，然后放入集合中处理，但这样执行效率会降低。
分类：
此处转载：https://blog.csdn.net/qq_43086494/article/details/87957608
Java中的集合类可以分为两大类：一类是实现Collection接口；另一类是实现Map接口。
1.Collection中，有三个子接口：Set,List,Queue
a. Set接口 : (不可重复)
1>HashSet:无序(事实上，内部是根据元素的hashcode进行排序的)
2>TreeSet:按照比较结果的升序进行进行排序
3>LinkedHashSet:按照添加顺序保存对象
b.List接口下主要有:
1>ArrayList:
1)有序，可以重复
2)查询速度快，增删改慢
2>LinkedList:
1)增删改速度快
2)查询速度慢
c.Queue ： 先进先出的
d.Vector ： 矢量队列
2.Map中
a.Hashmap：
1>通过键值对的方式来存储
2>其中key值可以不重复,value可以重复
3>扩容:当元素装满容器的75%时(默认大小16)，扩容2倍
b.LinkedHashMap：如果需要按照插入顺序查询,可以使用
c.Hashtable:和HashMap类似，不同的是HashTable不允许键或值为空
d.TreeMap:需要有排序功能的集合(默认升序，也可以指定)
特点：
集合类的特点有三个：
第一点，集合类这种框架是高性能的。对基本类集（动态数组，链接表，树和散列表）的实现是高效率的。一般人很少去改动这些已经很成熟并且高效的APl；
第二点，集合类允许不同类型的集合以相同的方式和高度互操作方式工作；
第三点，集合类容易扩展和修改，程序员可以很容易地稍加改造就能满足自己的数据结构需求。
好处：
（1）降低编程难度：在编程中会经常需要链表、向量等集合类，如果自己动手写代码实现这些类，需要花费较多的时间和精力。调用Java中提供的这些接口和类，可以很容易的处理数据。
（2）提升程序的运行速度和质量：Java提供的集合类具有较高的质量，运行时速度也较快。使用这些集合类提供的数据结构，程序员可以从“重复造轮子”中解脱出来，将精力专注于提升程序的质量和性能。
（3）无需再学习新的APl：借助泛型，只要了解了这些类的使用方法，就可以将它们应用到很多数据类型中。如果知道了LinkedList
（4）增加代码重用性：也是借助泛型，就算对集合类中的元素类型进行了修改，集合类相关的代码也几乎不用修改。
二. 创建线程有哪几种方式？有什么好处？
四种，分别是：
（1）通过继承Thread 来创建线程
需要定义一个子类来继承，需要重写run()方法，该方法中的方法体就是要执行的程序。
一般情况下是不建议这种方法来创建线程，因为java是单继承结构，一旦继承了Thread类，就无法继承其他类了，所以建议使用 实现Runable接口 的方法。
1）
public class ExtendsThreadTest extends Thread { //ExtendsThreadTest继承Thread类
@Override
public void run() { //run方法执行需要执行的内容
System.out.println("thread is running！");
}
public static void main(String[] args) {
ExtendsThreadTest et1 = new ExtendsThreadTest(); //创建类对象实例et1
et1.start(); //因为是继承类，所以可以调用继承来的 start()方法启动线程
}
}
2）
public class FirstThread extends Thread{
int i = 0;
//重写run方法，
public void run(){
for(;i<1000 ;i++){
System.out.println(getName()+" "+i);
//之所以可以直接调用Therad类的getName()方法，是因为该类继承了Thread类
}
}
public static void main(String[] args) {
for(int i=0;i<100;i++){
//获取当前线程：这里是主线程
System.out.println("当前线程："+Thread.currentThread().getName()+" "+i);
if(i == 10){
//启动第一个线程
new FirstThread().start();
//启动第二个线程
new FirstThread().start();
}
}
}
}
（2）通过实现Runnable接口创建线程
需要定义Runnable接口的实现类ThreadTest类，并重写该接口的run()方法。
1）
public class RunnableTest implements Runnable{ //创建实现Runnable接口的实现类RunnableTest类
@Override
public void run() { //重写run()方法
System.out.println("thread is running！");
}
public static void main(String[] args) {
Thread t1 = new Thread(new RunnableTest()); //由RunnableTest创建一个Thread实例对象
t1.start(); //调用线程对象的start()方法启动线程
}
}
2)
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();
}
}
}
}以上这两种方法如果线程类使用的很少，那么可以使用匿名内部类来实现线程：
public class ThreadTest{
public static void main(String[] args){
new Thread(new Runnable() { //实现Runnable接口的匿名内部类写法
@Override
public void run() {
System.out.println("thread1 is running！");
}
}){}.start();
new Thread(){ //继承Thread类的匿名内部类写法
@Override
public void run(){
System.out.println("thread2 is running！");
}
}.start();
}
}(3)使用Callable和Future创建线程，通常说法是通过实现Callable接口创建线程
Callabled接口有点儿像是Runnable接口的增强版，它以call()方法作为线程执行体，call()方法比run()方法功能更强大。
call()方法可以有返回值，可以声明抛出异常类。获取call()方法里的返回值: 通过FutureTask类（实现Future接口）的实例对象的get()方法得到，得到结果类型与创建TutureTask类给的泛型一致。
此处说明转载：https://www.jianshu.com/p/22d6ebe1b30a
FutureTask 是一个可取消的异步计算任务，是一个独立的类，实现了 Future、Runnable接口。FutureTask 的出现是为了弥补 Thread 的不足而设计的,可以让程序员跟踪、获取任务的执行情况、计算结果 。
因为 FutureTask实现了 Runnable，所以 FutureTask 可以作为参数来创建一个新的线程来执行，也可以提交给 Executor 执行。FutureTask 一旦计算完成，就不能再重新开始或取消计算。
FutureTask的构造方法
可以接受 Runnable,Callable 的子类实例。
//创建一个 FutureTask，一旦运行就执行给定的 Callable。
public FutureTask(Callable callable);
//创建一个 FutureTask，一旦运行就执行给定的 Runnable，并安排成功完成时 get 返回给定的结果 。
public FutureTask(Runnable runnable, V result) FutureTask 的简单例子
public class Test {
public static void main(String[] args) throws InterruptedException, ExecutionException {
FutureTask task = new FutureTask(new MyCallable());
//创建一个线程，异步计算结果
Thread thread = new Thread(task);
thread.start();
//主线程继续工作
Thread.sleep(1000);
System.out.println("主线程等待计算结果...");
//当需要用到异步计算的结果时，阻塞获取这个结果
Double d = task.get();
System.out.println("计算结果是："+d);
//用同一个 FutureTask 再起一个线程
Thread thread2 = new Thread(task);
thread2.start();
}
}
class MyCallable implements Callable{
@Override
public Double call() {
double d = 0;
try {
System.out.println("异步计算开始.......");
d = Math.random()*10;
d += 1000;
Thread.sleep(2000);
System.out.println("异步计算结束.......");
} catch (InterruptedException e) {
e.printStackTrace();
}
return d;
}
} 此处说明转载：https://www.cnblogs.com/jinggod/p/8485106.html#top
（4）使用线程池ExecutorSerice、Executors
前面三种方法，都是显式地创建一个线程，可以直接控制线程，如线程的优先级、线程是否是守护线程，线程何时启动等等。而第四种方法，则是创建一个线程池，池中可以有1个或多个线程，这些线程都是线程池去维护，控制程序员不需要关心这些细节，只需要将任务提交给线程池去处理便可，非常方便。
创建线程池的前提最好是你的任务量大，因为创建线程池的开销比创建一个线程大得多。
创建线程池的方式
ExecutorService 是一个比较重要的接口，实现这个接口的子类有两个 ThreadPoolExecutor (普通线程池)、ScheduleThreadPoolExecutor (定时任务的线程池)。你可以通过这两个类来创建一个线程池，但要传入各种参数，不太方便。
为了方便用户，JDK中提供了工具类Executors，提供了几个创建常用的线程池的工厂方法。
Executors 创建单线程的线程池的两个例子
1）
public class MyTest {
public static void main(String[] args) {
//创建一个只有一个线程的线程池
ExecutorService executorService = Executors.newSingleThreadExecutor();
//创建任务，并提交任务到线程池中
executorService.execute(new MyRunable("任务1"));
executorService.execute(new MyRunable("任务2"));
executorService.execute(new MyRunable("任务3"));
}
}
class MyRunable implements Runnable{
private String taskName;
public MyRunable(String taskName) {
this.taskName = taskName;
}
@Override
public void run() {
System.out.println("线程池完成任务："+taskName);
}
}
2）
public class ThreadPoolTest {
public static void main(String[] args) {
// 创建线程池
ExecutorService threadPool = Executors.newFixedThreadPool(10);
while(true) {
threadPool.execute(new Runnable() { // 提交多个线程任务，并执行
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " is running ..");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
}
}此处说明转载：https://www.cnblogs.com/jinggod/p/8485106.html#top
1）采用实现Runnable、Callable接口的方式创见多线程时，优势是：
线程类只是实现了Runnable接口或Callable接口，还可以继承其他类。
在这种方式下，多个线程可以共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。
劣势是：
编程稍微复杂，如果要访问当前线程，则必须使用Thread.currentThread()方法。
2）使用继承Thread类的方式创建多线程时优势是：
编写简单，如果需要访问当前线程，则无需使用Thread.currentThread()方法，直接使用this即可获得当前线程。
劣势是：
线程类已经继承了Thread类，所以不能再继承其他父类。
3）通过Executor来启动线程比使用Thread的start方法更好，除了更易管理，效率更好（用线程池实现，节约开销）外，还有关键的一点：有助于避免this逃逸问题——如果我们在构造器中启动一个线程，因为另一个任务可能会在构造器结束之前开始执行，此时可能会访问到初始化了一半的对象用Executor在构造器中。
三. 创建线程池有几种方式？区别是什么？
通常开发者都是利用Executors提供的通用线程池创建方法，去创建不同配置的线程池，主要区别在于不同的
Executors目前提供了5种不同的线程池创建配置：
1、newCachedThreadPool（），它是用来处理大量短时间工作任务的线程池，具有几个鲜明特点：它会试图缓存线程并重用，当无缓存线程可用时，就会创建新的工作线程；如果线程闲置时间超过60秒，则被终止并移除缓存；长时间闲置时，这种线程池，不会消耗什么资源。其内部使用SynchronousQueue作为工作队列。
2、newFixedThreadPool（int nThreads），重用指定数目（nThreads）的线程，其背后使用的是无界的工作队列，任何时候最多有nThreads个工作线程是活动的。这意味着，如果任务数量超过了活动线程数目，将在工作队列中等待空闲线程出现；如果工作线程退出，将会有新的工作线程被创建，以补足指定数目nThreads。
3、newSingleThreadExecutor()，它的特点在于工作线程数目限制为1，操作一个无界的工作队列，所以它保证了所有的任务都是被顺序(FIFO, LIFO, 优先级)执行，最多会有一个任务处于活动状态，并且不予许使用者改动线程池实例，因此可以避免改变线程数目。
4、newSingleThreadScheduledExecutor()和newScheduledThreadPool(int corePoolSize)，创建的是个ScheduledExecutorService，可以进行定时或周期性的工作调度，区别在于单一工作线程还是多个工作线程。
5、newWorkStealingPool(int parallelism)，这是一个经常被人忽略的线程池，Java 8 才加入这个创建方法，其内部会构建ForkJoinPool，利用Work-Stealing算法，并行地处理任务，不保证处理顺序，newWorkStealingPool适合使用在很耗时的操作，但是newWorkStealingPool不是ThreadPoolExecutor的扩展，它是新的线程池类ForkJoinPool的扩展，但是都是在统一的一个Executors类中实现，由于能够合理的使用CPU进行对任务操作（并行操作），所以适合使用在很耗时的任务中。
import lombok.experimental.Delegate;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadUtil {
//维护一个单例线程
private static final ThreadUtil threadUtil = new ThreadUtil();
// 代理模式 这样可以直接调用父类中的方法
// public interface ExecutorService extends Executor
//public interface Executor {
/**
* Executes the given command at some time in the future. The command
* may execute in a new thread, in a pooled thread, or in the calling
* thread, at the discretion of the {@code Executor} implementation.
*
* @param command the runnable task
* @throws RejectedExecutionException if this task cannot be
* accepted for execution
* @throws NullPointerException if command is null
*/
void execute(Runnable command);
}
// 1.采用newCachedThreadPool创建线程池
@Delegate
public ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
//2.采用newFixedThreadPool创建线程池
@Delegate
public ExecutorService service = Executors.newFixedThreadPool(3);
//3.采用newScheduledThreadPool 创建一个定长线程池 支持定时及周期性任务执行。
// 使用方法： ThreadUtil.getInstance().schedule(new TestThread(),3, TimeUnit.SECONDS);
@Delegate
public ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(2);
//4.采用newSingleThreadExecutor 创建一个单线程化的线程池
@Delegate
public ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();
//5.采用newWorkStealingPool创建线程池
@Delegate
public ExecutorService newWorkStealingPool= Executors.newWorkStealingPool();
public static ThreadUtil getInstance() {
return threadUtil;
}
}
@Override
public String sendMsg() throws Exception {
//把业务内容放在类中
ThreadUtil.getInstance().execute(new TestThread());
//或者这样直接写业务内容
ThreadUtil.getInstance().execute( () -> {
System.out.println("222");
// 打印线程的内存地址
System.out.println(System.identityHashCode(Thread.currentThread()));
System.out.println(Thread.currentThread().getName());
}
);
return "ok";
}
private class TestThread implements Runnable{
@Override
public void run() {
System.out.println("111");
System.out.println(Thread.currentThread().getName());
System.out.println(System.identityHashCode(Thread.currentThread()));
}
}