第一章 java多线程编程

线程与进程

   传统dos系统采用单进程处理，传统的单进程处理的最大特点：在同一个时间段上只允许一个程序在执行。
   后来window时代，开启多进程时代，在一个时间段上可以同时运行多个程序，并且这些程序进行资源的轮流抢占，因为当时是单核CPU，所以在同一个时间段上会有多个程序一次执行，但在同一个时间点上只会有一折进程执行。多核CPU，即便有再多的进程出现，也可以比单核cup处理速度有所提升。
   线程是在进程基础上划分的更小的程序单元，线程是在进程的基础上创建并使用的，所以线程依赖于进程的支持。线程的启动速度要比进程快许多， 所以使用多线程进行并发处理的时候，其执行的性能要高于进程（进程是在操作系统上的划分，线程是在进程上的划分，线程的执行速度要比进程快）
   Java是多线程的编程语言，所以Java在进行并发访问处理的时候可以得到更高的处理性能。

Java中实现多线程的定义，需要有一个专门的线程主体类进行线程的执行任务的定义，而这个主体类必须实现特定的接口或者继承特定的父类才能完成。

继承Thread类实现多线程

   **继承Thread类**
   Java里面提供一个java.lang.Thread的类，一个类只要继承了此类就表示这个类为线程的主体，但是并不是说这个类就可以实现多线程处理了，还需要覆写Thread类提供的run()（public void run 主方法没有返回值）方法，这个方法就属于线程的主方法。
   多线程要执行的功能都应该在run()方法中进行定义。需要说明：在正常情况下如果想要使用一个类中的方法，那么肯定要产生实例化对象，而后调用类中提供的方法，但是run方法时不能直接被调用的，因为这里面牵扯到一个资源的调度问题， 所以要想启动多线程必须使用start方法完成。
   疑问？？？？？为什么多线程的启动不直接使用run方法而必须使用start方法？？？？
   查看start方法源码：

         public synchronized void start() {
        if (threadStatus != 0)           //判断线程状态
            throw new IllegalThreadStateException()；//抛出一个异常
        group.add(this);
        boolean started = false;
        try {
            start0();        //在start（）方法里调用了start0（）。 
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
            }
        }
    }
    private native void start0(); //只定义了方法，但是没有实现

start方法里抛出“ IllegalThreadStateException”异常类对象，但是整个过程并没有使用throws或者是明确的try catch处理，因为该异常一定是一个RuntimeException的子类，每一个线程类的对象只允许启动一次，如果重复启动则抛出异常此异常。

在java程序执行的过程中考虑到对于不同层次开发这的需求，所以其支持有本地的操作系统函数调用，这项技术技术称为JNI（java native interface）技术，但是java开发过程之中并不推荐这样使用，利用这项技术可以使用一些操作系统提供的底层函数进行一些特殊的处理，而在Thread类里提供的start0就表示需要将此方法依赖于不同的操作系统实现

jvm识别.class文件，但jvm并不能真正执行，它只起到中间的过渡缓冲以实现可执行性。不同的操作系统有一套自己的执行算法（需与硬件标准进行绑定），用于调度资源，硬件上有它的执行标准。启动多线程时start()找到start0()，start0（抽象方法结构）由JVM实现，Jvm根据不同的操作系统来实现，所以start0的实现是由JVM做中间匹配得来。JVM找到操作系统的底层函数与操作系统交互，由这些底层函数最终实现算法的控制，而后有算法控制资源的访问，这就是Thread的执行分析。
任何情况下，只要定义了定义了多线程，启动永远只有一种方案：Thread类中的start（）。start0()用JNI技术实现。

Runnable接口实现多线程

java继承有单继承缺陷。第二种是实现java.lang.Runnable接口。但是Runnable接口中没有start()方法，仅继承该接口没法启动该线程。观察Thread类的构造方法publicThread（Runnable target）：该构造方法可以接受Runnable。可以将Runnable接口的子类对象传递给Thread的构造方法中，然后调用start()方法，来启动线程。
##没有了单继承的缺点，这样的设计才是一个标准型设计。
##从JDK1.8开始，Runnable接口使用了函数式接口定义， 所以也可以直接利用Lambda表达式进行线程类的实现。
##在以后的开发中优先使用Runnable接口。

Tread与Runnable关系

##代码结构本身：使用Runnable接口方便，因为可以避免单继承的局限，同时也可以更好的进行功能的扩充。
##结构上两者之间的联系：

public class Thread
extends Object
implements Runnable

发现Thread类也是Runnable接口的子类，那么之前继承Thread类的时候实际上覆写的还是Runnable接口的run方法。

##多线程的设计中，使用了代理设计模式的结构，用户自定义的线性主体只负责项目核心功能的实现，而所有的辅助实现全部交由Thread类来处理。
##在进行Tread类启动多线程的时候调用的是start()方法，而后找到run()方法，但通过Thread类的构造方法传递了一个Runnable接口对象的时候，那么该接口对象将被Thread类中的target属性（Runnable）所保存，在start()方法执行的时候会调用Thread类中的run方法，而这个run方法去调用Runnable接口子类被覆写过的run方法 。

public void run() {
        if (target != null) {
            target.run();
        }
    }

##多线程开发的本质在于多个线程可以进行同一资源的的抢占，那么Thread主要描述的是线程，而资源通过Runnable描述

##Runnable可以更好地描述多个线程访问同一资源的功能

Callable实现多线程

从最传统的开发来讲如果要进行多线程的实现肯定依靠Runnable，但是Runnable接口有一个缺点：当线程执行完毕后无法获取一个返回值，所以JDK1.5之后就提出一个新的线程实现接口：java.util.concurrent.Callable接口。

public interface Callable<V>{
public V call()
throws Exception；
}

Callable定义的时候可以设置一个泛型，此泛型的类型就是返回数据的类型，好处是可以避免向下转型带来的安全隐患。

Runnable与Callable的区别？
*Runnable在JDK1.0的时候提出多线程的实现接口，Callable是在JDK1.5之后提出的；
*java.lang.Runnable接口中只提供一个run方法，并且没有返回值；
*java.util.Callable接口提供一个call方法，可以有返回值；

线程的运行状态

对于多线线程开发而言，编写程序的过程之中总是按照：定义线程主体类，而后通过Thread类进行线程的启动，但是并不意味这调用了start方法，线程就运行了，因为整体的线程处理有自己的一套运行的状态

1、任何一个线程对象都应该使用Thread类进行封装，所以线程的启动使用的是start方法，但是启动的时候若干个线程都将进行到一种就绪的状态，现在并没有执行。
2、进入到我们就绪状态之后就需要等待进行资源调度，当某一个线程调动成功之后则进入到运行状态（run()方法），但是所有的线程不可能一直持续的执行下去，中间需要产生一些暂停状态，例如，某个线程执行一段时间之后就需要让出资源，而后这个线程就进入到阻塞状态，随后重新回归到就绪状态；
3、当run方法执行完毕之后，实际上该线程的主要任务也就结束了，那么此时就可以进入到停止状态0