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<String>的使用方法,也会知道LinkedList<Double>怎么用,则无需为每一种数据类型学习不同的API。

(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<V> callable);

//创建一个 FutureTask,一旦运行就执行给定的 Runnable,并安排成功完成时 get 返回给定的结果 。
public FutureTask(Runnable runnable, V result)

 FutureTask 的简单例子


public class Test {
  public static void main(String[] args) throws InterruptedException, ExecutionException {
    FutureTask<Double> 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<Double>{

    @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()));
    }
}