Java多线程编程
在Java中最大的特点是支持多线程的开发，所以在整个Java技术中，如果不能对多线程的概念有一个全面细致的了解，则在项目设计过程中尤其是并发访问的过程中出现严重的技术缺陷。
进程与线程
如果要理解线程，那么首先要理解进程的概念，在传统DOS时代，其本身特征：若出现病毒，那么所有程序无法执行，因为DOS采用的是单进程处理。而单进程处理的最大特点：在同一时间段只允许一个程序执行。
Windows开启了多进程设计，表示一个时间段上可以同时运行多个程序，这些程序会进行资源的轮流抢占。在同一时间段上会有多个程序依次执行，但是在同一个时间点上只会有一个进程执行，而到了多核CPU，由于可以处理的CPU多了，那么即便有再多的进程出现，也可以比单核CPU处理的速度有所提升。
线程：是在进程基础上划分的更小的程序单元，线程是在进程基础上创建并使用，所以线程依赖于进程的支持，但是线程的启动速度要比进程快很多，所以使用多线程进行并发处理时，其执行的性能要高于进程。
Java是多线程的编程语言，所以Java在进行并发访问处理的时候可以得到更高的性能。
继承Thread类实现多线程
要在Java中实现多线程的定义，需要一个专门的线程主体类进行线程的执行任务的定义，这个主体类的定义是有要求的，必须实现特定的接口或继承特定的父类才可以完成。
Java中提供有一个java.lang.Thread的程序类，只要继承此类表示为线程的主体类，但并不是说这个类就可以直接实现多线程处理，因为还需要覆写Thread类中提供的一个run方法，这个方法就属于线程的主方法。
多线程主体类
class MyThread extends Thread{
//实现线程的主体类，
private String title;
public MyThread(String title) {
this.title = title;
}
@Override
public void run() {
//线程的主体方法
for(int x = 0; x<10; x++) {
System.out.println(this.title +"运行，x="+ x);
}
}
}
多线程要执行的功能都应该在run()中进行定义。需要说明的是：在正常情况下如果要使用一个类中的方法，那么肯定要产生实例化对象而后调用类中的方法，而run方法不能直接调用，这里面牵扯到资源调度问题，要想启动多线程必须**使用start()**方法。
虽然调用start方法，但最终执行的是run()方法，并且所有的线程对象都是交替执行的，但执行顺序不是可控的。
问：为什么不直接使用run而是必须使用Thread类中start方法呢？
在start()中会抛出一个"IllegalThreadStateException"异常类对象，但是程序并未进行处理，因为该异常是RunTimeException的之类。
每一个线程类的对象只允许启动一次，如果重复启动就抛出此异常。
MyThread mt = new MyThread("线程A");
mt.start();
mt.start(); //错误
在Java程序执行过程中考虑到对于不同层次开发者的需求，所以其支持有本地的操作系统函数调用，这项技术称为JNI，但并不推荐，利用这项技术可以使用一些操作系统提供的底层函数进行特殊处理，Thread类中提供的start0()方法就表示此方法需要依赖不同操作系统实现。
任何情况下，只要定义了多线程，多线程的启动永远只有一种方案：Thread类中的start()方法。
Runnable接口实现多线程
Java中对于继承存在单继承局限，所以在Java中提供第二种多线程定义结构:实现Java.lang.Runnable接口。
class MyThreadRun implements Runnable{
//实现线程的主体类，
private String title;
public MyThreadRun(String title) {
this.title = title;
}
@Override
public void run() {
//线程的主体方法
for(int x = 0; x<10; x++) {
System.out.println(this.title +"运行，x="+ x);
}
}
}
public class ThreadDemo {
public static void main(String[] args) {
Thread thRun = new Thread(new MyThreadRun("线程B")); //Runnable实现
thRun.start();
}
}
但是此时不再继承Thread父类，此时类中也不再支持start()方法，此时使用Thread对象接收Runnable对象。
此时多线程可以发现，由于只是实现了Runnable接口对象，所以此时线程主体类上不再有单继承局限，这样的设计才是标准的设计。
现在Runnable为函数式编程接口所以可以直接使用Lambda表达式进行线程的实现。
public class ThreadDemo {
public static void main(String[] args) {
for(int x=0;x<3;x++) {
String title = "线程名称-"+x;
Runnable run = ()->{
for(int y = 0; y<10; y++) {
System.out.println(title +"运行，y="+ y);
}
};
new Thread(run).start();
}
}
}
以后开发中多线程优先考虑Runnable实现，永恒都是通过Thread类对象启动多线程。
Thread与Runnable的关系
从代码结构本身来讲使用Runnable是最方便的，因为其可以避免单继承的局限，同时也可以更好的进行功能的扩充。
但是从结构上也需要观察Thread与Runnable的联系。
public class Thread Object implements Runnable{}
发现Thread类也是Runnable接口的子类，那么之前继承Thread类的时候还是覆写的Runnable接口的run()方法。
多线程设计之中使用了代理设计模式的结构，用户自定义的线程主体知识负责项目核心功能的实现，而所有的辅助实现全部交由Thread类处理。
在进行Thread启动多线程的时候调用的是start()方法，而后找到的是run()方法。当通过Thread类的构造方法传递了一个Runnable的接口对象时，那么该接口对象将被Thread类中的target属性保存。在start()方法执行的时候会调用Thread类中的run()方法，而这个run()方法去调用Runnable接口子类被覆写过的run()方法。
多线程开发的本质实质上是在于多个线程可以进行同一资源的抢占，Thread主要描述的是线程，资源的描述是由Runnable完成的。
范例：利用买票程序实现多个线程的资源并发访问。
class MyThreadRun implements Runnable{
//实现线程的主体类，
private int ticket = 5;
private String title;
@Override
public void run() {
//线程的主体方法
for(int x = 0; x<100; x++) {
if(this.ticket > 0 ) {
System.out.println(this.title +"买票，余票="+ this.ticket --);
}
}
}
}
public class ThreadDemo {
public static void main(String[] args) {
MyThreadRun mt = new MyThreadRun();
new Thread(mt).start(); //第1个线程启动
new Thread(mt).start(); //第2个线程启动
new Thread(mt).start(); //第3个线程启动
}
}
内存分析：
Callable接口实现多线程
从最传统的开发来讲要进行多线程的实现肯定依靠的就是Runnable，但是Runnable的接口有一个缺点：当线程执行完毕之后无法获取一个返回值。所以从JDK1.5之后提出一个新的线程实现接口：java.util.concurrent.Callable。
@FunctionalInterface
public interface Callable<V>{
public V call() throws Exception;
}
发现Callable定义的时候可以设置一个泛型，此泛型的类型就是返回数据的类型。这样可以避免向下转型带来的安全隐患。
范例：使用Callable实现多线程处理
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
class MyThreadRun implements Runnable{
//实现线程的主体类，
private int ticket = 5;
private String title;
@Override
public void run() {
//线程的主体方法
for(int x = 0; x<100; x++) {
if(this.ticket > 0 ) {
System.out.println(this.title +"买票，余票="+ this.ticket --);
}
}
}
}
public class ThreadDemo {
public static void main(String[] args) throws Exception{
FutureTask<String> task = new FutureTask<>(new MyThreadCal());
new Thread(task).start();
System.out.println("线程返回数据" + task.get());
}
}
面试：解释Runnable和Callable的区别？
- Runnable是在Jdk1.0提出的多线程实现接口，而Callable是JDK1.5提出的；
- Runnable接口中只提供run()方法且无返回值；
- Callable提供有call()方法，可以有返回值；
多线程运行状态
对于多线程的开发而言，编写程序的过程之中总是按照：定义线程主体类，而后通过Thread类进行线程的启动，然而并不意味着你调用了start()方法，线程就已经开始运行了，因为整体的线程处理有自己的一套运行的状态。
- 任何一个线程的对象都应该使用Thread类进行封装，所以线程的启动使用的是start()，但是启动的时候实际上若干个线程都将进入到一种就绪状态，现在并未执行；
- 进入就绪状态之后就需要等待进行资源调度，当某一个线程调度成功之后则进入到运行状态(run()方法)，但是所有的线程不可能一直持续执行下去，中间需要产生一些暂停的状态，如某些线程执行一段时间之后就需要让出资源，而后这个线程就将进入到阻塞状态，然后重新回到就绪状态。
实际上若干个线程都将进入到一种就绪状态，现在并未执行； - 进入就绪状态之后就需要等待进行资源调度，当某一个线程调度成功之后则进入到运行状态(run()方法)，但是所有的线程不可能一直持续执行下去，中间需要产生一些暂停的状态，如某些线程执行一段时间之后就需要让出资源，而后这个线程就将进入到阻塞状态，然后重新回到就绪状态。
- 当run()方法执行完毕之后，实际上该线程的主要任务也就结束了，此时就可以直接进入到停止状态。