多线程（一）多线程入门

1. 多线程是什么

多线程就是，程序运行中的多条执行路径。

1. 程序：代码和数据的有序集合，代码最终编辑成指令给CPU执行，数据是指令的操作对象。
2. 进程：运行中的程序实例（如QQ可以启动多个），拥有系统分配的独立的地址空间。
3. 线程：cpu在进程中的一条执行路径，也就是指令的有序集合。

2. 为什么会有多线程

1. 很多时候，一条指令的完成，并不全部在CUP内部，会涉及磁盘IO、网络请求等，而CPU的运算能力远远高于外部，这时，如果是单线程，则会造成CPU大量的等待时间。
2. 对比：人的大脑如CPU，可以一边发出走路的指令（大脑外部），一边发出说话的指令（大脑外部），一边处理听到的声音（大脑内部）等。也就是说，思考速度远高于行动速度。

3. 多线程有什么用

1. 提高CPU效率，也就是提高程序效率。
2. 避免阻塞，提高程序响应速度，后台处理磁盘IO、网络请求等消耗较多资源和时间的操作。
3. 多核CPU得到充分利用

4. 多线程的缺点

1. 创建和销毁线程需要消耗系统资源
2. CPU在线程之间的切换，也会带来额外的开销
3. 线程之间对共享资源的访问会相互影响，造成了开发难度的极大提高，不当的开发会产生大量问题

备注：需要根据实际情况使用多线程和控制线程数量

5. 多线程的应用

1. Tomcat、Jboss等Web服务器使用多线程处理请求
2. 异步处理需要大量时间的任务，如ajax、文件上传下载等

备注：node.js、nginx等新一代http server是单线程处理请求，效率更高

3. 创建线程四种方式

不管哪种方式，最终都是通过Thread.start()来启动一个线程，这是native方法

1. 继承Thread类

public class ExtendsThreadTest {
    public static void main(String[] args) {
        MyExtendsThread t1 = new MyExtendsThread();
        t1.setName("第一个线程的名称");
        MyExtendsThread t2 = new MyExtendsThread();
        t2.setName("第二个线程的名称");
        t1.start();
        t2.start();
    }
}
class MyExtendsThread extends Thread {
    @Override
    public void run() {
        System.out.println("继承Thread创建线程，线程名称：" + getName());
    }
}
/**output
继承Thread创建线程，线程名称：第二个线程的名称
继承Thread创建线程，线程名称：第一个线程的名称
*/

2. 实现Runnable接口

public class ImplementsRunnableTest {
    public static void main(String[] args) {
        MyImplementsRunnableThread task = new MyImplementsRunnableThread();
        Thread t1 = new Thread(task);
        t1.setName("第一个线程的名称");
        Thread t2 = new Thread(task);
        t2.setName("第二个线程的名称");
        t1.start();
        t2.start();
    }
}
class MyImplementsRunnableThread implements Runnable {
    @Override
    public void run() {
        System.out.println("实现Runnable创建线程，线程名称：" + Thread.currentThread().getName());
    }
}
/**output
实现Runnable创建线程，线程名称：第一个线程的名称
实现Runnable创建线程，线程名称：第二个线程的名称
*/

3. 实现Callable接口，再用FutureTask包装，有返回值，可抛出异常，但接收结果是阻塞式的

public class ImplementsCallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyImplementsCallableThread t = new MyImplementsCallableThread();
        FutureTask<String> futureTask = new FutureTask<>(t);
        Thread thread = new Thread(futureTask);//为什么不直接Thread thread = new Thread(t)，因为Thread类是jdk1.0就出来了，而Callable是jdk1.5才出来的，这是对线程的优化，前两种线程没有返回值，也不能抛出异常
        thread.start();
        String result = futureTask.get();//阻塞等待子线程返回结果
        System.out.println("result: " + result);
    }
}

class MyImplementsCallableThread implements Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println("实现Callalbe接口创建线程，线程名称: " + Thread.currentThread().getName());
        return "线程返回结果";
    }
}
/**output
实现Callalbe接口创建线程，线程名称: Thread-0
result: 线程返回结果
*/

4. 使用线程池，避免线程重复创建和销毁的开销

// 1. 无返回值，jdk定义线程池
public class ThreadPoolTest {
    public static void main(String[] args) {
        Executor executor = Executors.newCachedThreadPool();
        MyThreadTask task = new MyThreadTask();
        executor.execute(task);
    }
}
class MyThreadTask extends Thread {
    @Override
    public void run() {
        System.out.println("通过线程池创建线程，线程名称: " + getName());
    }
}
/**output
通过线程池创建线程，线程名称: Thread-0
*/

// 2. 有返回值，自定义线程池
public class ThreadPoolTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
    	// 线程数量根据实际情况决定
        ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 3, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<>(3));
        MyThreadTask task = new MyThreadTask();
        Future<String> submit = executor.submit(task);
        System.out.println(submit.get());

    }
}
class MyThreadTask implements Callable<String> {
    @Override
    public String call() {
        System.out.println("有返回值、自定义线程池，线程名称: " + Thread.currentThread().getName());
        return "子线程执行结果";
    }
}
/**output
有返回值、自定义线程池，线程名称: pool-1-thread-1
子线程执行结果
*/

备注：所有线程池最终都是通过ThreadPoolExecutor创建

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
    if (corePoolSize < 0 ||
        maximumPoolSize <= 0 ||
        maximumPoolSize < corePoolSize ||
        keepAliveTime < 0)
        throw new IllegalArgumentException();
    if (workQueue == null || threadFactory == null || handler == null)
        throw new NullPointerException();
    this.acc = System.getSecurityManager() == null ?
            null :
            AccessController.getContext();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

4. 守护线程

1. 单个线程不存在守护线程和非守护线程的概念
2. 非守护线程：没有守护线程的线程
3. 守护线程：在start()前，设置thread.setDaemon(true)，这样就形成了被守护线程和守护线程
4. 守护线程随着被守护线程的结束而结束
5. 守护线程创建的线程也是守护线程