多线程的实现方式

一、线程、进程、单线程、多线程

1. 进程：执行中的程序，一个进程可以包含一个或多个线程，一个进程至少要包含一个线程。
2. 线程：线程是一个程序里面不同的执行路径。
3. 单线程：程序中只存在一个线程，实际上主方法就是一个主线程。
4. 多线程：多线程是一个程序中运行多个任务，多线程是为了更好的使用CPU资源。

注意：所谓多线程看上去是同步执行，实际上那是因为cpu进行了时间分片，同一个时间点只会执行一个线程，因为cpu计算很快，所以看上去好像是同步执行。

二、JAVA实现多线程的方式

1. Thread类
   通过继承java.lang.Thread类来实现。
   继承Thread类必须重写run方法，demo：

public class MyThread extends  Thread {
    private String name;
    public MyThread(String name){
        this.name = name;
    }
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println(name+":"+i);
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        MyThread t1 = new MyThread("A");
        MyThread t2 = new MyThread("B");
        t1.start();
        t2.start();
    }
}

2. Runnable接口
   通过直接实现Runnable来实现多线程。

public class MyRunnable implements Runnable {
    private String name;
    public MyRunnable(String name){
        this.name = name;
    }
    @Override
    public void run() {
        for (int i = 0; i <1000 ; i++) {
            System.out.println(name+":"+i);
        }
    }
}

public class RunnableTest {
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyRunnable("A"));
        Thread t2 = new Thread(new MyRunnable("B"));
        t1.start();
        t2.start();
    }
}

3. Callable接口
   从Java 1.5开始，就提供了Callable和FutureTask，通过它们可以在任务执行完毕之后得到任务执行结果。

public class MyCallable  implements Callable{
    private String name;
    public MyCallable(String name){
        this.name = name;
    }
    @Override
    public Object call() throws Exception {
        for (int i = 0; i < 1000; i++) {
            System.out.println(name+":"+i);
        }
        return null;
    }
}

public class CallableTest {
    public static void main(String[] args) {
        Thread t1 = new Thread(new FutureTask(new MyCallable("A")));
        Thread t2 = new Thread(new FutureTask(new MyCallable("B")));
        t1.start();
        t2.start();
    }
}

4. ExecutorService 线程池创建
   使用线程池必须要掌握ThreadPoolExecutor这个对象：

   
   ThreadPoolExecutor.png
   

   通过上图可以看出来，ThreadPoolExecutor是ExecutorService 的实现类。
   与此类相关的还需要掌握一个类Executors:

   
   Executors.png
   如图所示，该类提供了一系列封装好的静态方法，可以返回ExecutorService对象，该类主要提供的方法大致分为:指定长度的线程池、单个线程的线程池、非核心线程的缓存线程池、支持定时和周期性任务的线程池等。
   通过示例可以更清楚的去理解：

public class ExecutorServiceTest {
    public static void main(String[] args)  {
        ExecutorService service = Executors.newSingleThreadExecutor();
        try {
            // 支持Callable<T>,Runnable
            Future task = service.submit(new MyCallable("A"));
            // 可以拿到线程执行完的返回值,返回值类型同call方法的返回值类型一致
            Object obj =task.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }finally {
            service.shutdown();
        }
    }
}