现在的操作系统是多任务操作系统。多线程是实现多任务的一种方式。
进程与线程
进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在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 {
/**
* 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 {
@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 single1 = executor.submit(single);
Future 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 single1 = new FutureTask(single);
FutureTask single2 = new FutureTask(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实际上就是在操作系统中启动了一个进程。