01-多线程(概述)
接下来，我们来说一说Java中特有的一个知识技术：多线程。
在说线程这个概念之前呢，需要说一个更显而易见的概念：进程。
何为进程呢？进程就是正在进行中的程序。
进程可以同时开启，其实就是cpu在对它们执行。
不过，虽然它们看起来像是同时在执行，其实，cpu在某一时刻只能执行某一个程序，它只是在做着超快的切换，咻咻咻咻~才导致我们看到的是各个程序在同时执行。
再讲个迅雷的例子。是不是有时候会有多条下载请求呀？一个进程，里面可能会有多条执行路径。什么意思呢？在我们进行迅雷下载的时候呢，大家都知道迅雷可以有多条下载路径，比如100M的文件，迅雷可能会分成五个部分，一个部分一个部分的同时发送请求到服务端去下载数据。我们想一想，如果我们下载是用一个路径，就是先下载第一个数据，然后一个一个下载，一直下载到第100个数据。可是如果是五条路径下载，五个人同时在搬东西，是不是就比一个人快多啦？而且这五个人都是在这一个进程中哦，这其中的每一个人，就叫做线程。线程是进程中的内容，每一个应用程序，里面都至少有一个线程。
线程有一个特点，它是程序中的控制单元，或者叫执行路径。
总结一下：
进程：是一个正在执行中的程序。
每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。
每个程序执行，都需要启动内存空间，而进程其实就是用来标识内存空间的，它用来封装里面的那些控制单元。
线程：就是进程中的一个独立的控制单元。
线程在控制着进程的执行。
一个进程中至少有一个线程。
以Java为例，编译运行的时候，它有两个进程：编译进程和运行进程。
我们重点说一下运行进程。
Java虚拟机启动的时候会有一个进程java.exe。该进程中至少有一个线程来负责Java程序的执行，而且这个线程运行的代码存在于main方法中。该线程称之为主线程。
其实，很多书里面都在说，这个程序在启动执行的时候是单线程程序，因为还没有其他线程存在呢。这样说理解也是对的。
扩展：
但是，如果你深究一下虚拟机的话，其实不是单线程。虚拟机启动的时候，它就是多线程。为什么呢？另外的线程是谁呢？
试想一下，（这个只作为了解喔，因为说这个程序是单线程也没问题哒）程序在运行的时候，是不是要建立对象，调用方法，这个时候是主线程在帮我们做这件事情，堆里面会产生很多对象，如果其中某一个对象不被使用了，它就会被垃圾回收机制回收了。主线程还在继续执行着其他对象中的操作，而这个对象就被干掉了，是不是在同时进行呐？是滴！
这个时候就产生了一个问题，主线程在继续调用方法的同时，另外的不被使用的对象就被垃圾回收机制回收了。所以这个时候虚拟机至少有两个线程，一个是主线程，一个是垃圾回收的线程。
多线程存在的意义是什么呢？
多线程的出现呢，可以让我们程序中的部分产生同时运行的效果。而且在下载东西的时候，多线程下载还可以帮我们提高效率。
02-多线程(创建线程-继承Thread类)
那么，如何在我们的程序中自定一个控制单元，或者说，自定一个线程？
Java中已经为我们提供好了对这类事物的对象体现。
通过对API的查找，我们发现，java的核心包java.lang包中就有一个对象叫做Thread，它就是程序中的执行线程，就是用于描述控制单元这类事物的对象。
我们发现创建新执行线程有两种方法：
连范例都有啦，我们自己来写~
创建线程的第一种方式：继承Thread类。
第一步，继承Thread类：
接下来我们看看Thread中的run方法是怎样的~
第二部，重写run方法：
继承完之后，我们接下来就要创建它的对象啦。注意哦，建立好一个对象，其实就是创建好一个线程。
创建好对象之后就要调用run方法啦。
我们看到范例中有一个start方法：
查一下start方法是干什么的~
OK，写好啦：
现在编译运行：
demo run成功打印了。
总结一下， 创建线程的第一种方式：继承Thread类的步骤为：
1，定义类继承Thread。
2，复写Thread类中的run方法。
3，调用线程的start方法，该方法有两个作用：启动线程，调用run方法。
冷静下来思考一下，但是这跟我们以前调用方法的方式有什么区别呢？怎么看不出来呀？
接下来我们让它多运行一会儿，写了一个循环~
让hello world也参与一下~
编译运行：
我们分析一下它的执行路径：
所以我们在打印结果的时候是交替打印的。
为什么是交替的呢？main线程和d线程它们俩不是同时执行吗？
跟你讲哦，真实情况下是不可能的。
windows本身是一个多任务操作系统，看上去它确实在同时执行，其实真正的情况是，cpu在某一时刻下，只能执行一个程序。为什么看起来是同时执行的呢？因为cpu在这些程序之间做着快速的切换，切换的速度是相当快的，快到你根本感觉不出来它在切换，所以你觉得它在同时执行。
而进程中真正在执行的是线程，所以cpu在切换的是每一个进程中的线程。而一个进程中有多个线程的话，cpu也要做切换呢。（这也是机器中程序开的越多越慢的原因）
我们现在就不说多进程啦，我们就说其中一个进程好啦。
在这个例子中，这一个进程中，就已经有多个线程啦。cpu执行main一会儿，执行d一会儿。那么这种情况，我们形象的把它称之为，多个线程在抢劫cpu资源。这只是一种形象的说法，其实是cpu说了算。只是说“抢”更形象一点儿~
#Java小剧场
cpu：执行main一会儿，执行main一会儿，好了好了，再执行d一会儿，再执行d一会儿，再执行d一会儿，诶，好像都没顾到main了，那我再执行main一会儿好了。。。
#
早期有一些病毒就是通过消耗cpu资源让电脑死机的。它就是一直在抢用cpu资源，从而达到让别人抢不着的效果。
再回到我们的例子中。
到这里main线程就结束啦，那这个进程会结束吗？不会。因为d线程还没有结束，只要d线程还在，这个进程就存在。
现在有了双核、多核处理器，就可以实现同时运行了，这个cpu处理这个，那个cpu处理那个。不过具体是怎么切换的，我们现在暂时控制不了，可以学一下多核编程玩一下~
双核以后谁是瓶颈？内存。
#Java小剧场
小楠老师在做一个一对三的高考冲刺班，她同时带三个孩子，一会给这个辅导，一会给那个辅导，还算忙得过来。这个时候又有一个人报名了，小楠老师忙不过来了，于是就又请了一位老师，这位新老师来带新报名的这个孩子。这样，小楠老师和新老师可以同时带四个孩子。
小楠老师的补习班空间不大，四个孩子就刚好坐满啦。其实新老师也可以再带两个孩子呢，这样小楠老师和新老师就可以同时带六个孩子，达到最大的效率。可是因为补习班太小，不能容纳更多孩子，小楠老师和新老师还是只能带四个孩子。
#
现在双核之后，还有四核、八核，听起来好腻害哦。但是可能会出现cpu想处理数据但没数据处理的情况。（没有地方装数据呀）
再回到刚刚的例子中。我们又多运行了几次，发现每次运行打印的顺序都不同。
因为多个线程都在获取cpu的执行权。cpu执行到谁，谁就运行。
明确一点，在某一个时刻，只能有一个程序在运行。（多核除外）
cpu在做着快速的切换，以达到看上去是同时运行的效果。
我们可以形象的把多线程的运行行为看做在互相抢夺cpu的执行权。
这就是多线程的一个特性：随机性。谁抢到谁执行，至于执行多长时间，cpu说的算。
当然，也会出现这样的情况，hello world执行完了，才执行demo run，或者demo run执行完了，才想起来执行hello world。这种情况是cpu切换得有点慢。哈哈~迟钝的cpu~
再当然，在没有被特意控制的情况下，不会出现cpu把一个全部执行完再执行另一个的情况。 因为cpu它在优化资源，它得去快速的做着切换，才能实现同时运行的效果，否则会出现一个程序在执行，另一个程序执行不了。
04-多线程(线程练习)
练习：创建两个线程，和主线程交替运行。
运行结果：
这样写会怎样呢：
还是只有一个主线程在执行，另外两个线程没有开启。
主线程先打印one run，再打印two run，最后打印main。
这里我们的循环只有60次，所以主线程运行一段程序的时候，其他程序等待时间不会太长，但是如果是6000、60000次呢？这个其他程序的等待时间就很长啦。
所以，建立多个线程，多个程序就可以“同时”运行~
05-多线程(线程运行状态)
线程的四种状态：
06-多线程(获取线程对象以及名称)
我们来看看关于线程名称的方法，有setName：
getName：
我们用getName方法来获取一下线程名称。
依然用之前的那个例子~
编译运行：
我们发现有Thread-1和Thread-0两个名字。
原来线程都有自己默认的名称。
Thread-编号 该编号从0开始。
我们也可以改变线程的名称，用setName方法就好啦。
不过查一下Thread的构造函数，发现线程初始化的时候就可以有名称啦！
我们调用一下父类的构造方法：
现在在创建它们的时候就给它们起一下名字：
编译运行：
自定义线程名称成功啦~
另外，Thread类还为我们提供了一个方法：currentThread()。
这个方法是静态的，说明这个对象没有访问到对象的特有数据，用类名访问就可以啦。
我们使用这个方法，来获得当前线程的名称：
获取成功~（运行截图略，就和this.getName()运行结果一样）
既然两种方法运行结果一样，它们有什么不同呢？
试一下：
运行：
运行结果是true哦。所以它俩是一样哒。
那用this调用就行了呀，多简单，用currentThread那么长，那么麻烦。
不是的。this调用的方式并不通用，只有在类的对象调用类中方法时才可以用则中方式调用。而currentThread是标准通用方法，无论谁调用都可以用~
我们来复习一下：
static Thread currentThread()：获取当前线程对象。
getName()：获取线程名称。
设置线程名称：setName()或者构造函数。
还有一个小问题：
Thread-0和Thread-1“同时”运行的时候，用的x是同一个吗？
不是的。
Thread-0建立的时候，内存中会为它分配一块内存空间，其中有一块叫x；Thread-1建立的时候，内存也会为它分配另一块内存空间，其中也有一块叫x。多个线程“同时”运行的时候，注意局部变量是每个内存空间中都有一份哦。
07-多线程(售票的例子)
接下来，我们用一个事例来对第二种方法进行阐述。
需求：简单的卖票程序。
多个窗口同时卖票。
现在4个窗口同时卖票：
运行一下，发现分不清都是哪个窗口卖的：
打印一下线程的名字：
运行，我们发现了一个问题：
1、2、3、4号窗口都卖了1号票。一节车厢就100个座，可是现在卖出了400个座。
问题在于，创建一个对象，里面就有100张票。
我们的解决方式：让4个对象共享100张票。
该用静态啦！
运行：
OK啦。没有重复卖票的啦。
但是，我们一般是不是不定义静态呀？因为它的生命周期太长啦！
那怎么解决呢？
用一个对象来卖100张票：
运行：
是不是也卖完啦~
但是发现这些乱七八糟什么东西呀：
也就是说，线程已经开启了，并且调用start函数，从开启状态进入了运行状态。这个时候又调用了start函数，又进入运行状态，这就是无效的呀。
该怎么解决呢？
快接着看下去~
08-多线程(创建线程-实现Runnable接口)
解决这个问题，我们就需要引入第二种创建线程的方式了。
我们来看一下Runnable接口：
这个接口里面非常的爽呀，就一个方法：
我们来跟着示例代码来写~emmm...不太懂耶。
那慢慢一步一步分析着来~先让Ticket类实现Runnable接口：
主函数中：
我们现在需要想办法让线程调用Ticket中的run，需要让Ticket中的run和Thread创建的对象有关系！
我们需要在创建线程对象时就明确要运行什么代码。
Thread有一个构造方法，比较特殊：
它可以接收Runnable接口类型的对象。
所以这就是我们要实现Runnable接口的原因，因为Thread类认识这个Runnable接口。
所以，我们在new Thread方法的同时，就可以指定run方法所属的对象。
编译运行：
搞定！
这就是创建线程的第二种方式：实现Runnable接口。
步骤：
1，定义类实现Runnable接口。
2，覆盖Runnable接口中的run方法。
将线程要运行的代码存放在该run方法中。
3，通过Thread类建立线程对象。
4，将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
为什么要将Runnable接口的子类对象传递给Thread的构造函数？
因为，自定义的run方法所属的对象是Runnable接口的子类对象。
所以要让线程去指定对象的run方法。就必须明确该run方法所属的对象。
5，调用Thread类的start方法开启线程，并调用Runnable接口子类的run方法。
那么，这两种创建线程的方式，也就是实现方式和继承方式有什么区别呢？
我们先讲一下Runnable接口的由来：
左边的Student类，没有父类，它里面的run方法需要被多线程执行，所以就继承了Thread类。
可是，Student在演变的过程中，抽取出来了一个父类Person，这个时候Student类中的run方法需要被多线程执行，但是因为它已经有父类了，而Java又不支持多继承，所以无法再继承Thread类。
这时，Java提供了一个Runnable接口来解决这个问题，“你可以不叫我爸爸，我也可以帮你执行代码，只要你符合我的规则就行”，将这个功能抽取出来封装到了Runnable接口中。
这就是接口的由来。
因此，实现方式的好处：避免了单继承的局限性，把它作为了一种功能的扩展封装在了接口中。在定义线程时，建议使用实现方式。
而且这个构造方法使用了多态：
因为日后会出现什么样的接口子类是无法预知的，所以它用了多态的形式，你只要符合规则，它都可以用！你只要符合PCI的规则，后期粗现什么样的版本，它都可以帮你运行！
我们发现，Thread类本身也实现了Runnable接口：
Runnable接口的定义，其实就是在确立线程要运行代码所存放的位置。
两种创建线程的方式还有一个区别：
继承Thread：线程代码存放在Thread子类的run方法中。
实现Runnable：线程代码存放在接口子类的run方法中。
它们代码的存放位置不一样。
当然，如果你的类没有父类，用第一种方式也是完全可以的。
09-多线程(多线程的安全问题)
现在只剩最后一张票了，然后4个窗口都拿到了执行资格，在等待执行权，最后执行权比如说给了0号，0号卖出后执行权比如给了1号，这个时候1再继续执行票数就为负了，这显然不符合常理。我们的程序有bug啦！
我们现在模拟一下这个过程，让我们真实的看到这个现象。
怎么做呢？
那怎么让它睡一下呢？
看一下sleep方法：
我们看一下这个方法的特点：
它是静态的，没有访问到对象的特有数据，并且它抛出了异常。
话不多说，写起来：
因为Ticket实现了Runnable接口，而这个接口并未抛出异常，所以Ticket也不能抛出异常，所以只能try哦。
运行一下：
刚刚那个问题就出现啦。
通过分析，发现，打印出0，-1，-2等错票。
多线程的运行出现了安全问题。
安全问题最可怕辣！
多线程中一定要小心安全问题，一旦产生就非常要命。
问题的原因：
当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行，导致了共享数据的错误。
解决办法：
对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他过程不可以参与执行。
Java对于多线程的安全问题提供了专业的解决方式。
就是同步代码块。
synchronized(对象)
{
需要被同步的代码
}
写起来~
运行看一下效果：
OK啦！
10-多线程(多线程同步代码块)
在上节课中，这里有个对象：
这个对象如同锁，持有锁的线程可以在同步中执行。
没有持有锁的线程，即使获得了cpu的执行权，也进不去，因为没有获取锁。
火车上的卫生间就是一个经典的的例子。
同步的前提：
1，必须要有两个或者两个以上的线程才需要同步。（就你一个人用这个卫生间，就不需要锁门啦）
2，必须是多个线程使用同一个锁才需要同步。（多个人使用的是同一个卫生间）
必须保证同步中只能有一个线程在运行。
同步的好处：
解决了多线程的安全问题。
不过它也有弊端：虽然解决了问题，但是执行的时候每次都要判断这个锁，所以较为消耗资源。（越安全越麻烦）