请你说说多线程

什么是进程

1. 程序是用来解决问题、用某种语言编写的静态代码。
2. 进程是运行的程序，是动态的，会由计算机分配内存和资源。
3. 线程进程可进一步细分为线程，是一个程序内部的一条执行路径。

•         如果一个进程同一时间并行执行多个线程，就是支持多线程的。
•        线程是操作系统调度和执行的最小单元，每个线程拥有独立的运行栈和程序计数器。 
•         一个进程中的多个线程共享相同的内存单元-->它们从同一堆中分配对象，可以访问相同的对象和变量。这就使得线程间的通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全隐患（进程安全问题）。

多线程的优点

1.提高了计算机系统CPU的利用率；

2.提高应用程序的响应。对图形化界面更有意义，可增强用户体验；

3.改善程序结构。将即长又复杂的进程分为多个线程，独立运行，方便了理解和维护。同时Java为多线程提供了良好而一致的编程模型，使开发人员能够更加专注于问题的修改，开发者只需为此问题建立合适的业务模型，而无需绞尽脑汁地考虑如何实现多线程。一旦开发者建立好了业务模型，稍作修改就可以将其方便地映射到Java提供的多线程编程模型上。

适合使用多线程的情况

1.程序需要同时执行两份或多个任务；

2程序需要实现一些需要等待的任务时，如用户输入、文件读写、网络操作、搜索等；

3.需要一些后台运行的程序时。

Java中如何使用多线程（4种方式）

1.继承Thread类

public class Thread1 extends java.lang.Thread {
    public Thread1() {
    }

    public Thread1(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            /*currentThread():Returns a reference to the currently executing thread object.
                                -返回当前正在执行的线程对象的引用。
                               Returns:the currently executing thread
                                -返回：当前执行的线程
            */
            System.out.println(currentThread().getName());
        }

    }
}
//测试方法
    @Test
    public void testThread1() {
        Thread1 thread1 = new Thread1("first");
        thread1.start();
    }

2.实现Runnable类

//多线程实现方式2：继承java.lang.Thread类，再重写run()方法
public class Thread2 implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(currentThread().getName());
        }

    }
}
    //测试方法    
    @Test
    public void testThread2() {
        Thread2 thread = new Thread2();
        Thread Thread1 = new Thread(thread);
        Thread Thread2 = new Thread(thread);

        Thread1.start();
        Thread2.start();
    }

3.实现Callable类

//实现Callable接口并重写call()方法，在使用时与FutureTask配合使用。
public class Thread3 implements Callable {
    @Override
    public Object call() throws Exception {
        for (int i = 0; i < 10; i++) {
            System.out.println(currentThread().getName());
        }

        return null;
    }
}
    //测试方法
    @Test
    public void testThread3(){
        Thread3 thread1 = new Thread3();
        Thread3 thread2 = new Thread3();
        FutureTask futureTask1 = new FutureTask(thread1);
        FutureTask futureTask2 = new FutureTask(thread2);
        new Thread(futureTask1).start();
        new Thread(futureTask2).start();


    }

4.使用进程池

    @Test
    public void testThread4() {
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) service;
//        设置核心线程数
        threadPoolExecutor.setCorePoolSize(10);
        //设置线程在终止之前可能保持空闲的时间限制。
        threadPoolExecutor.setKeepAliveTime(1000, MILLISECONDS);
        //execute()参数是实现了runnable接口的类的对象
        service.execute(new Thread2());
        service.execute(new Thread2());
//        submit()方法参数是实现了callable接口的类的对象
        service.submit(new Thread3());
        service.submit(new Thread3());

        //shutdown()：启动有序关闭，其中执行先前提交的任务，但不会接受新任务。 如果已经关闭，调用没有额外的效果。
        service.shutdown();
    }