java中有三种多线程：

1.继承Thread类，重写run方法。Thread本质上也是一个实现了Runnable的实例，他代表一个线程的实例，并且启动线程的唯一方法就是通过Thread类的start方法

2.实现Runnable接口，并实现该接口的run()方法.创建一个Thread对象，用实现的Runnable接口的对象作为参数实例化Thread对象，调用此对象的start方法。

3.实现Callable接口，重写call方法。Callable接口与Runnable接口的功能类似，但提供了比Runnable更强大的功能。有以下三点
1）.Callable可以在人物结束后提供一个返回值，Runnable没有提供这个功能。
2）.Callable中的call方法可以抛出异常，而Runnable的run方法不能抛出异常。
3）.运行Callable可以拿到一个Future对象，表示异步计算的结果，提供了检查计算是否完成的方法。

需要注意的是，无论用那种方式实现了多线程，调用start方法并不意味着立即执行多线程代码，而是使得线程变为可运行状态

注意下面开始处理多线程回调问题（结合java8）：
关于多线程结果处理，主要包括两个对象（Future和CompletableFuture），实现Callable的线程返回值就是一个Future对象，而CompletableFuture则是观察线程池的执行状态，并且CompletableFuture还可以实时回调线程结果，相当于ios中的block（函数是编程），实时观察，按需回调，当然CompletableFuture也含有异常情况处理。

来看代码：
线程1(实现Runnable情况)：

public class ThreadOne implements Runnable {
    private static Logger logger = LogManager.getLogger(ThreadOne.class);


    private String thumbUrl;
    private String imgName;
    public ThreadOne(String thumbUrl, String imgName) {
        this.thumbUrl = thumbUrl;
        this.imgName = imgName;
    }


    @Override
    public void run() {

        String imgPath = ImageTools.downLoadImg(this.thumbUrl,"images/",this.imgName);
        logger.info("多线程下载任务1="+imgPath);
    }
}

线程2(实现Callable情况)：

public class ThreadTwo implements Callable {
    private static Logger logger = LogManager.getLogger(ThreadTwo.class);

    private String thumbUrl;
    private String imgName;
    public ThreadTwo(String thumbUrl, String imgName) {
        this.thumbUrl = thumbUrl;
        this.imgName = imgName;
    }

    @Override
    public Object call() throws Exception {

        String imgPath = ImageTools.downLoadImg(this.thumbUrl,"images/",this.imgName);
        logger.info("多线程任务二=="+imgPath);
        return imgPath;
    }
}

主函数：

public class ThreadTest {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        //开启多个实现线程1
        Thread threadOne = new Thread(new ThreadOne("http://image.haiziyouke.com/series2.jpg","series1.png"));
        threadOne.start();

        Thread threadOne1 = new Thread(new ThreadOne("http://image.haiziyouke.com/series2.jpg","series2.png"));
        threadOne1.start();

        Thread threadOne2 = new Thread(new ThreadOne("http://image.haiziyouke.com/series2.jpg","series3.png"));
        threadOne2.start();

        Thread threadOne3 = new Thread(new ThreadOne("http://image.haiziyouke.com/series2.jpg","series4.png"));
        threadOne3.start();




        //开启多个线程2
        //创建线程池
        ExecutorService excutor= Executors.newFixedThreadPool(5);
        //创建Callable对象任务
        ThreadTwo calTask5=new ThreadTwo("http://image.haiziyouke.com/series3.jpg","series5.png");
        //提交任务并获取执行结果
        Future<String> future5 =excutor.submit(calTask5);

        //创建Callable对象任务
        ThreadTwo calTask6=new ThreadTwo("http://image.haiziyouke.com/series4.jpg","series6.png");
        //提交任务并获取执行结果
        Future<String> future6 =excutor.submit(calTask6);

        //创建Callable对象任务
        ThreadTwo calTask7=new ThreadTwo("http://image.haiziyouke.com/series5.jpg","series7.png");
        //提交任务并获取执行结果
        Future<String> future7 =excutor.submit(calTask7);

        //创建Callable对象任务
        ThreadTwo calTask8=new ThreadTwo("http://image.haiziyouke.com/series6.jpg","series8.png");
        //提交任务并获取执行结果
        Future<String> future8 =excutor.submit(calTask8);

        //创建Callable对象任务
        ThreadTwo calTask9=new ThreadTwo("http://image.haiziyouke.com/series7.jpg","series9.png");
        //提交任务并获取执行结果
        Future<String> future9 =excutor.submit(calTask9);


        //必须至少有一个线程执行完毕才会进入到这里面(实时观察线程的Future结果)
        CompletableFuture<String> resultFuture=CompletableFuture.supplyAsync(()->{

            System.out.println("进入到CompletableFuture里面来");
            //这里面是一直观察者多线程（excutor），我们可以获取、处理当前线程池中每个线程的状态
            try {
                if (future5.get()!=null&&future6.get()!=null&&future7.get()!=null&&future8.get()!=null&&future9.get()!=null){
                    return "所有线程结束了";
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
            return "我结束了，开始回调吧==";

        },excutor);


        //他是一直观察着CompletableFuture，等他有返回结果时，才会触发他的闭包
        resultFuture.thenAcceptAsync((m)->{
            System.out.println("线程收到结果="+m);
            System.out.println("回调主函数---->继续执行主线程");
            //显示声明异常处理
        }).exceptionally((t)->{
            System.out.println("异常处理开始");
            System.out.println(t.getMessage());
            return null;
        });

        //关闭线程池
        excutor.shutdown();
    }

}

会用了再来深刻理解下多线程：
1、多线程有什么用？
一个可能在很多人看来很扯淡的一个问题：我会用多线程就好了，还管它有什么用？在我看来，这个回答更扯淡。所谓”知其然知其所以然”，”会用”只是”知其然”，”为什么用”才是”知其所以然”，只有达到”知其然知其所以然”的程度才可以说是把一个知识点运用自如。OK，下面说说我对这个问题的看法：
（1）发挥多核CPU的优势
随着工业的进步，现在的笔记本、台式机乃至商用的应用服务器至少也都是双核的，4核、8核甚至16核的也都不少见，如果是单线程的程序，那么在双核CPU上就浪费了50%，在4核CPU上就浪费了75%。单核CPU上所谓的”多线程”那是假的多线程，同一时间处理器只会处理一段逻辑，只不过线程之间切换得比较快，看着像多个线程”同时”运行罢了。多核CPU上的多线程才是真正的多线程，它能让你的多段逻辑同时工作，多线程，可以真正发挥出多核CPU的优势来，达到充分利用CPU的目的。
（2）防止阻塞
从程序运行效率的角度来看，单核CPU不但不会发挥出多线程的优势，反而会因为在单核CPU上运行多线程导致线程上下文的切换，而降低程序整体的效率。但是单核CPU我们还是要应用多线程，就是为了防止阻塞。试想，如果单核CPU使用单线程，那么只要这个线程阻塞了，比方说远程读取某个数据吧，对端迟迟未返回又没有设置超时时间，那么你的整个程序在数据返回回来之前就停止运行了。多线程可以防止这个问题，多条线程同时运行，哪怕一条线程的代码执行读取数据阻塞，也不会影响其它任务的执行。
（3）便于建模
这是另外一个没有这么明显的优点了。假设有一个大的任务A，单线程编程，那么就要考虑很多，建立整个程序模型比较麻烦。但是如果把这个大的任务A分解成几个小任务，任务B、任务C、任务D，分别建立程序模型，并通过多线程分别运行这几个任务，那就简单很多了。

2、start()方法和run()方法的区别
只有调用了start()方法，才会表现出多线程的特性，不同线程的run()方法里面的代码交替执行。如果只是调用run()方法，那么代码还是同步执行的，必须等待一个线程的run()方法里面的代码全部执行完毕之后，另外一个线程才可以执行其run()方法里面的代码。

3、Runnable接口和Callable接口的区别
有点深的问题了，也看出一个Java程序员学习知识的广度。Runnable接口中的run()方法的返回值是void，它做的事情只是纯粹地去执行run()方法中的代码而已；Callable接口中的call()方法是有返回值的，是一个泛型，和Future、FutureTask配合可以用来获取异步执行的结果。这其实是很有用的一个特性，因为多线程相比单线程更难、更复杂的一个重要原因就是因为多线程充满着未知性，某条线程是否执行了？某条线程执行了多久？某条线程执行的时候我们期望的数据是否已经赋值完毕？无法得知，我们能做的只是等待这条多线程的任务执行完毕而已。而Callable+Future/FutureTask却可以获取多线程运行的结果，可以在等待时间太长没获取到需要的数据的情况下取消该线程的任务，真的是非常有用。

4、CyclicBarrier和CountDownLatch的区别

两个看上去有点像的类，都在java.util.concurrent下，都可以用来表示代码运行到某个点上，二者的区别在于：
（1）CyclicBarrier的某个线程运行到某个点上之后，该线程即停止运行，直到所有的线程都到达了这个点，所有线程才重新运行；CountDownLatch则不是，某线程运行到某个点上之后，只是给某个数值-1而已，该线程继续运行
（2）CyclicBarrier只能唤起一个任务，CountDownLatch可以唤起多个任务
（3）CyclicBarrier可重用，CountDownLatch不可重用，计数值为0该CountDownLatch就不可再用了

5、Volatile关键字的作用(结合iOS 多线程来看看)
一个非常重要的问题，是每个学习、应用多线程的Java程序员都必须掌握的。理解volatile关键字的作用的前提是要理解Java内存模型，这里就不讲Java内存模型了，可以参见第31点，volatile关键字的作用主要有两个：
（1）多线程主要围绕可见性和原子性两个特性而展开，使用volatile关键字修饰的变量，保证了其在多线程之间的可见性，即每次读取到volatile变量，一定是最新的数据
（2）代码底层执行不像我们看到的高级语言—-Java程序这么简单，它的执行是Java代码–>字节码–>根据字节码执行对应的C/C++代码–>C/C++代码被编译成汇编语言–>和硬件电路交互，现实中，为了获取更好的性能JVM可能会对指令进行重排序，多线程下可能会出现一些意想不到的问题。使用volatile则会对禁止语义重排序，当然这也一定程度上降低了代码执行效率
从实践角度而言，volatile的一个重要作用就是和CAS结合，保证了原子性，详细的可以参见java.util.concurrent.atomic包下的类，比如AtomicInteger。

6、什么是线程安全
又是一个理论的问题，各式各样的答案有很多，我给出一个个人认为解释地最好的：如果你的代码在多线程下执行和在单线程下执行永远都能获得一样的结果，那么你的代码就是线程安全的。
这个问题有值得一提的地方，就是线程安全也是有几个级别的：
（1）不可变
像String、Integer、Long这些，都是final类型的类，任何一个线程都改变不了它们的值，要改变除非新创建一个，因此这些不可变对象不需要任何同步手段就可以直接在多线程环境下使用
（2）绝对线程安全
不管运行时环境如何，调用者都不需要额外的同步措施。要做到这一点通常需要付出许多额外的代价，Java中标注自己是线程安全的类，实际上绝大多数都不是线程安全的，不过绝对线程安全的类，Java中也有，比方说CopyOnWriteArrayList、CopyOnWriteArraySet
（3）相对线程安全
相对线程安全也就是我们通常意义上所说的线程安全，像Vector这种，add、remove方法都是原子操作，不会被打断，但也仅限于此，如果有个线程在遍历某个Vector、有个线程同时在add这个Vector，99%的情况下都会出现ConcurrentModificationException，也就是fail-fast机制。
（4）线程非安全
这个就没什么好说的了，ArrayList、LinkedList、HashMap等都是线程非安全的类