多线程-多线程基础

1. 快速认识线程

1.1 线程的介绍

对计算机来说每一个任务就是一个进程（Process），在每一个进程内部至少要有一个线程（Thread）是在运行中，有时线程也称为轻量级进程。
线程是程序执行的一个 路劲，每一个线程都有自己的局部变量表、程序计数器（指向正在执行的指令指针）以及各自的生命周期，当启动了一个java虚拟器（JVM）时，从操作系统开始就会创建一个新的（JVM进程），而JVM进程中将会派生或者创建很多线程。

1.2 快速创建并启动一个线程

​ java创建线程大概有四种方式：

1.2.1 继承Thread类实现多线程

public class MyThread extends Thread{
    //重写run方法
    public void run(){
        //做一些事
    }
}

1.2.2 实现Runnable()接口实现多线程

public class MyThread implements Runnable{
    public void run(){
        //做一些事
    }
}

二者之间的区别：

1. 实现Runnable接口可以避免多继承局限
2. 实现Runnable()可以更好的体现共享的概念

1.2.3 覆写Callable接口实现多线程

public class MyThread implements Callable{
    
    @Override
	public String call() throws Exception {
        //做一些事，有返回值
    }
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        Callable<String> callable  =new MyThread();
		FutureTask<String> futureTask=new FutureTask<>(callable);
		Thread mThread=new Thread(futureTask);
        mThread.start();
        //打印返回值
        System.out.println(futureTask.get());
    }
}

1.2.4 通过线程池启动多线程

通过Executor类创建三种类型的普通线程池：

• newFixedThreadPool(int n); 固定大小的线程池

public class MyThread implements Callable{
    
    @Override
	public String call() throws Exception {
        //做一些事，有返回值
    }
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //newFixedThreadPool(int n); 固定大小的线程池
        ExecutorService es = Executors.newFixedThreadPool(2);
        Callable<String> callable  =new MyThread();
        Future<String> f1 = es.submit(callable);
        //打印返回值
        System.out.println(f1.get());
        //销毁线程池
        es.shutdown();
    }
}

• newSingleThreadExecutor();单例线程池

public class MyThread implements Callable{
    
    @Override
	public String call() throws Exception {
        //做一些事，有返回值
    }
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //newFixedThreadPool(int n); 固定大小的线程池
        ExecutorService es = Executors.newSingleThreadExecutor();
        Callable<String> callable  =new MyThread();
        Future<String> f1 = es.submit(callable);
        //打印返回值
        System.out.println(f1.get());
        //销毁线程池
        es.shutdown();
    }
}

• newCashedThreadPool(); 缓存线程池

public class MyThread implements Callable{
    
    @Override
	public String call() throws Exception {
        //做一些事，有返回值
    }
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //newFixedThreadPool(int n); 固定大小的线程池
        ExecutorService es = Executors.newCachedThreadPool();
        Callable<String> callable  =new MyThread();
        Future<String> f1 = es.submit(callable);
        //打印返回值
        System.out.println(f1.get());
        //销毁线程池
        es.shutdown();
    }
}