Java中多线程与创建方式

现在的操作系统是多任务操作系统。多线程是实现多任务的一种方式。

进程与线程

进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。 比如在Windows系统中，一个运行的exe就是一个进程。

线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如Java.exe进程中可以运行很多线程。线程总是属于某个进程，进程中的多个线程共享进程的内存。
线程分为两类：用户线程和守候线程。
当所有用户线程执行完毕后，JVM自动关闭。但是守候线程却不独立与JVM，守候线程一般是有操作系统或用户自己创建的。

Java中线程生命周期

Java线程具有五中基本状态

新建状态(New)：新建线程对象就进入了新建状态，就像new一个Thread线程对象
就绪状态(Runnable)：当调用线程对象的start()方法，线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行。
运行状态(Running)：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。就绪状态是进入到运行状态的唯一入口，线程想进入运行状态执行，首先必须处于就绪状态中
阻塞状态(Blocked)：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才有机会再次被CPU调用以进入到运行状态。
根据阻塞产生的原因不同，阻塞状态又可以分为三种：
1.等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；
2.同步阻塞 – 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态
3.其他阻塞 – 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
死亡状态(Dead)：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

Java编写程序都运行在在Java虚拟机（JVM）中，在JVM的内部，程序的多任务是通过线程来实现的。每用Java命令启动一个Java应用程序，就会启动一个JVM进程。在同一个JVM进程中，有且只有一个进程，就是它自己。在这个JVM环境中，所有程序代码的运行都是以线程来运行。

在Java中创建线程

在创建实例前先创建类Singleton(线程不安全)

public class Singleton {
    private Singleton() {}
    private static Singleton single=null;
    //静态工厂方法
    public static Singleton getInstance() {
        if (single == null) {
            single = new Singleton();
        }
        return single;
    }
}

1.继承Thread类创建线程类

public class Single extends Thread{
    @Override
    public void run() {
        Singleton singleton=Singleton.getInstance();
        System.out.println(singleton);
    }
}

创建一个类继承扩展Thread类，在这子类中重写run()，在run()内写线程任务代码

在main方法中测试

public class DoTest {
    public static void main(String[] args) {
        Single single1 = new Single();
        Single single2 = new Single();
        Thread t1 = new Thread(single1);
        Thread t2 = new Thread(single2);
        t1.start();
        t2.start();
    }
}

创建该子类实例，即是创建了一个线程实例并调用该实例的start方法来启动该线程

结果：

2.实现Runnable接口创建线程类

public class Single implements Runnable{
    @Override
    public void run() {
        Singleton singleton=Singleton.getInstance();
        System.out.println(singleton);
    }
}

实现Runnable接口构造线程的方法是： 要在一个扩展了Runnable接口的类中实现接口中的抽象方法run()

在main方法中测试

public class DoTest {
    public static void main(String[] args) {
        Single single=new Single();
        new Thread(single).start();
        new Thread(single).start();
    }
}

Thread类的构造方法要求将一个Runable接口类型的对象作为参数，这个就将这个接口的run()与所声明的Thread对象绑定在一起，也就可以用这个对象的start()和sleep()来控制这个线程。

结果：

注：对于线程的启动而言，都是调用线程对象的start()方法，不能对同一线程对象两次调用start()方法。第二次调用必然会抛出IllegalThreadStateException，这是一种运行时异常，多次调用start()被认为是编程错误。

关于继承Thread类与实现Runnable接口的区别

1.使用继承Thread类实现多线程是多个线程分别完成自己的任务，实现Runnable接口实现多线程是多个线程共同完成一个任务。其实在实现一个任务用多个线程来做也可以用继承Thread类来实现只是比较麻烦，一般我们用实现Runnable接口来实现，简洁明了。
2.资源共享：继承Thread不适合资源共享。实现Runable接口的话很容易的实现资源共享。通过继承Thread类，每个线程都有一个相关联的唯一对象，而实现Runnable接口，多线程可以共享同一个Runnable实例。
3.Java单继承性，使用继承Thread有点局限，而实现Runable接口克服了单继承的限制，用接口的方式将你的代码和线程实现分离，更加清晰。

实现Runnable接口比继承Thread类所具有的优势：

1.适合多个相同的程序代码的线程去处理同一个资源
2.可以避免Java中的单继承的限制
3.增加程序的健壮性，代码可以被多个线程共享，代码和数据独立

不过这两种方式都有一个缺陷就是：在执行完任务之后无法获取执行结果。如果需要获取执行结果，就必须通过共享变量或者使用线程通信的方式来达到效果，这样使用起来就比较麻烦。

3.实现Callable接口创建线程类

Callable接口类似于 Runnable，Callable接口的任务线程能返回执行结果并且其call()允许抛出异常，而Runnable接口的run()方法的异常只能在内部消化，不能继续上抛

Callable接口源码

@FunctionalInterface
public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

Callable接口位于java.util.concurrent包下，在里面声明了一个call()
这是一个泛型接口，call()函数返回的类型就是传递进来的V类型。

Future表示异步计算的结果,就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过get()获取执行结果，该方法会阻塞直到任务返回结果。

使用Callable+Future获取执行结果

public class Single implements Callable<String> {
    @Override
    public String call() throws Exception {
        Singleton singleton=Singleton.getInstance();
        System.out.println(singleton);
        return "Callable+Future获取执行结果";
    }
}

这里我简单返回一句话

在main方法中测试

public class DoTest {
    public static void main(String[] args)  {
        ExecutorService executor = Executors.newCachedThreadPool();
        Single single = new Single();
        Future<String> single1 = executor.submit(single);
        Future<String> single2 = executor.submit(single);
        try {
            System.out.println(single1.get());
            System.out.println(single2.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }finally {
            executor.shutdown();
        }
    }
}

Callable一般要配合线程池ExecutorService来使用，ExecutorService是Executor直接的扩展接口，也是最常用的线程池接口，Executor的实现提供的一些方法可以返回一个Future对象， 通过它我们可以跟踪到异步任务的执行和停止。

测试结果

线程结果正常返回出来了

使用Callable+FutureTask获取执行结果
只需要修改main方法

public class DoTest {
    public static void main(String[] args)  {
        ExecutorService executor = Executors.newCachedThreadPool();
        Single single = new Single();
        FutureTask<String> single1 = new FutureTask<String>(single);
        FutureTask<String> single2 = new FutureTask<String>(single);
        executor.submit(single1);
        executor.submit(single2);
        try {
            System.out.println(single1.get());
            System.out.println(single2.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }finally {
            executor.shutdown();
        }
    }
}

测试结果

关于Future和FutureTask

FutureTask是Future接口的一个唯一实现类。
FutureTask实现了Runnable，因此它既可以通过Thread包装来直接执行，也可以提交给ExecuteService来执行。
FutureTask实现了Futrue可以直接通过get()函数获取执行结果，该函数会阻塞，直到结果返回。
如果需要使用 Future 但又不提供可用的结果，则可以声明 Future<?> 形式类型、并返回 null。

总结：

在Java中所有的线程都是同时启动的，至于什么时候，哪个先执行，完全看谁先得到CPU的资源。在Java中，每次程序运行至少启动两个线程。一个是main线程，一个是垃圾收集线程。因为每当使用Java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM实际上就是在操作系统中启动了一个进程。