Java多线程实现

什么是多线程？

多线程是一种多道程序设计技术道那是通道的道，在支持多道程序设计技术的计算机系统中可以并发的执行多条程序。在计算机系统中，一个计算核心在一个时间点只能处理一条程序，在不支持多道程序设计技术的计算机系统中，当一个程序占用计算机计算核心时，必须等待该程序运行完成，退出占用，下一条程序才能运行，如果程序在处理过程中，某一步，或者很多步的等待时间较长，则会严重降低系统的处理速度，如果！能将程序在等待的过程中使其退出计算核心让下一个程序进入核心开始执行，等该程序等待的处理完成以后，再进入计算核心进行处理，这样在原本做一件事的同时，做了两件事，甚至多件事，这便是多线程，多条线程争抢CPU执行（由调度算法决定），在单核系统中，多线程是伪多，是多条程序轮转争抢CPU，因为一个时间点只能有一条程序处理，但是在多核系统中却可以实现真正的多线程，实现高并发，当然想深入了解该技术，可以了解下计算机操作系统这门科学。

Java中实现多线程

Java实现多线程只要依靠两个方法，继承Thread类，实现Runnable接口，还有一个方法可以实现多线程，即是Java API中并发工具包（java.util.concurrent）下的Callable接口，下面我们将一一介绍。

继承Thread类

/**
 * @class ExtendThreadClass
 * @description ... 此代码适合对Java多线程具有一定了解的人士~~~~如果不了解，先看看书呗~
 * @date 2016年9月19日 下午11:19:52
 */
public class ExtendThreadClass {
    public static void main(String[] args) {
        // 方法一：继承Thread类，此处只讲如何实现多线程，备忘用，应用和理论，需要自己慢慢体会

        // 实例化对象
        ThreadTest thr = new ThreadTest();
        // 调用Thrad类的start()方法即可开始线程
        thr.start();
    }
}

/**
 * @class ThreadTest
 * @description ...通过继承Thread类实现多线程，这是一个嵌套类，嵌套在ExtendThreadClass里面的，只是
 * 为了方便写代码而已，完全可以单独写一个类
 * @date 2016年9月19日 下午11:21:59
 */
class ThreadTest extends Thread {

    @Override
    public void run() {
        System.out.println("Hello Java MulitThread");
    }

}

Runnable接口

/**
 * @class ImplementRunnableInterface
 * @description ...通过实现
 * @date 2016年9月19日 下午11:45:09
 */
public class ImplementRunnableInterface {
    public static void main(String[] args) {
        // 方法二实现多线程,虽然可以实例化ImpleRunnable，调用run()方法，但是这样是不对的，程序中不应该直接调用run()方法
        Thread thr = new Thread(new ImpleRunnable());
        thr.start();

        // 当然也可以将代码写成这样
        new Thread(new ImpleRunnable()).start();

        // 或者直接在需要线程的地方使用匿名内部类来实现，然后直接启动
        new Thread(new Runnable() {

            @Override
            public void run() {
                System.out.println("Runnable~~~~~~~");
            }
        }).start();

        // 也，当然，我们知道Runnable接口是一个函数式接口（即是你以前不知道，现在我也告诉你了），因此可以使用Lambda表达式(基于Java8)，因此，上面的程序也可以改写成
        new Thread(() -> {
            System.out.println("Use LambdaExpress~!");
        }).start();
    }
}

/**
 * @class ImpleRunnable
 * @description ...继承Runnable接口，并重写run()方法
 * @date 2016年9月19日 下午11:45:55
 */
class ImpleRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println("Runnable~~~~~~~");
    }

}

至于Callable接口

简单介绍几个概念：执行器Executor,位于Java.util.concurrent包下，用于启动并控制线程执行，是Thread类管理线程的一种替代方案，ExecutorService接口扩展了Executor接口，添加了用于帮助控制和管理线程的一些方法；Future接口，我们学习多线程通过上面两个例子应该发现了，通过Thread和Runnable两种方式都不能让线程返回一个值，因为这个并不支持，但是Callable支持在线程运行结束之后返回运行结果，而这个结果是在程序运行完以后，将来的一种状态，因为你并不确定线程运行时间，而多线程是异步执行，所以这种将来的结果Java中使用Future<T>接口来表示，要获取返回值，虚调用Future的get()方法。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * @class CallableInterface
 * @description ...使用Callable 接口实现多线程，依赖于执行器
 * @date 2016年9月19日 下午11:58:06
 */
public class CallableInterface {

    public static void main(String[] args) {

        // 产生一个大小为2的线程池来运行两条线程
        ExecutorService executor = Executors.newFixedThreadPool(2);

        // 执行一个返回结果为整数的线程（实现Callable）
        //正如Thread和Runnable都要实现run()方法一样，Callable需要实现call()方法
        //采用匿名内部类的实现方式
        Future<Integer> future = executor.submit(new Callable<Integer>() {

            @Override
            public Integer call() throws Exception {
                return 3;
            }

        });

        // 获取执行的结果,运行结果3
        try {
            System.out.println(future.get());
        } catch (Exception e) {
        }

        //我们又知道Callable为函数式接口，因此也可以使用Lambda表达式，程序如下
        Future<String> future_=executor.submit(()->{
            return "String!";
        });
        // 获取执行的结果,运行结果String!
        try {
            System.out.println(future_.get());
        } catch (Exception e) {
        }

        //使用完成要关机
        executor.shutdown();
    }
}

总结

写的比较匆忙，主要用于备忘，如果有幸被其他同学看到了，请见谅。