在Java中引入多线程的目的显而易见，当程序中有多部分代码需要同时执行，这时便需要引入多线程，将需要同时执行的代码作为线程任务（并发任务），来达到目的。
同时在这里，还有必要搞清一个问题，什么是同时执行？从字面意思来理解，就是同时执行！而事实上，是CPU瞬间在各个线程之间做着快速切换，这种切换在引入时间片技术的OS系统中，是按照时间片的技术来完成的。
在这行main函数中内容的同时，垃圾回收器的线程，同时执行！
线程创建的方式有两种
方式一：继承Thread类，覆盖run（）方法
步骤：
1.定义类覆盖Thread类；
2.覆盖Thread类中的run方法；
3.创建Thread类的子类对象创建线程对象；
4.调用线程对象的start（）方法，开启线程。
方式二：实现Runnable接口，重写run（）方法
1.定义一个类实现Runnable接口；
2.覆盖Runnable接口中的run（）方法，将线程要运行的代码存储到run（）方法中；
3.创建该接口的子类对象；
4.通过Thread类进行线程的创建，并将Runnable接口的子类作为Thread构造参数的实参进行传递；
5.调用Thread类的start（）开启线程。
两种创建方式的区别:
方式一：继承自Thread类，这就会收到Java单继承这种局限性的影响，当我们如果想扩展这个线程子类的功能时就会收到很大的
限制
方式二：实现Runnable接口，则可以避免方式一的局限性，极大的降低了任务对象和Thread对象的耦合，更加符合Java面向对象
编程的思想
线程安全问题
说到线程安全，我会想到售票窗口售票的情况，四个售票员同时出售这100张票，用Java程序来表示的话，就是四个线程共享一个数据，当其中一个线程在处理多条操作共享数据的过程中，其他线程参与了运算，这时就会发生线程安全问题。
线程安全的解决办法？
只要保证一个线程在执行多条操作共享数据的语句时，其他线程不能参与运算即可，当该线程都执行完后，其他线程才可执行这些语句。
锁--同步代码块，同步函数，静态同步函数使用的锁:
1.同步代码块使用的锁是：任意的对象；
2.同步函数使用的锁是：this，this代表当前对象的引用
3.静态--当一个类被加载进内存以后，在我们还没有创建对象的时候，已经有了xxx.class
静态随着类的加载而加载，这时内存中存储的对象至少有一个就是该类字节码文件对象
这个对象的表示方式：类名.class
静态同步函数的应用场景：单例模式
单例设计模式：保证一个类在内存中只能有一个对象
怎样才能保证对象是唯一的呢？
1.其他程序随时用new创建该类对象，无法控制个数；
2.不让其他程序创建，该类在本类中自己创建一个对象；
3.该类将创建的对象对位提供，让其他程序获取并使用。
步骤：
1.怎么实现不让其他程序创建该类对象呢？将该类中的构造函数私有化
2.在本类中创建一个本类对象，并私有化
3.定义一个方法，返回值类型是本类类型，让其他程序通过该方法就可以获取本类对象
懒汉式:
class Single{
private static Single s=null;
private Single(){}
public static Single getInstance(){
if(s==null){
s=new Single();
return s;
}
}
}
在并发访问单例的时候，懒汉式单例会被破坏，有可能不能保证对象的唯一性
例如：1线程进来后经过判断发现为null，正在准备创建对象时，CPU切换到了2线程；
2线程进来后，经过判断，发现也为null，正在准备创建对象时；
CPU又切换到了1线程，new Single（）；
此时CPU又切换到了2线程，也new Single（）；
这就不能保证了对象的唯一性。
解决方案？同步
class Single{
private static Single s=null;
private Single(){}
public static synchronized Single getInstance(){
if(s==null){
s=new Single();
}
return s;
}
}
但是，这样又带来一个新的问题：当程序中线程增多后，对锁的判断次数就会增多，从而影响程序的性能
那么，如何做到既保证了多线程的安全性，又可以提高程序的性能呢？那就要减少后续对锁的判断次数。
class Single{
private static Single s=null;
private Single(){}
private static Single getInstance(){
if(s==null){
synchronized(Single.class){
if(s=null){
s=new Single();
}
}
}
returns;
}
}
死锁？
指多个进程or线程在运行过程中因争夺资源而造成的一种僵局，当线程处于这种僵局时，若无外力作用，他们
无法继续往前执行。
最常见的死锁的情况：同步的嵌套
我们应当，尽量避免同步的嵌套情况
Thread类的方法：
run（）线程中真正起作用的语句放在run（）的方法体内，该方法在Thread的子类中覆盖或在Runnable对象覆盖
start（）程序通过调用线程的start（）方法执行线程，而start（）则调用run（）方法
sleep（long）它的一个参数指出当前执行的线程应休眠多长时间
interrupt（）用于中断一个线程
线程的生命周期
出生：新创建的线程处于出生born状态，在调用线程的start方法之前，该线程一直处于出生状态；
就绪：当调用start方法后，线程便进入了就绪状态ready
运行：当系统给线程分配处理器资源时，处于就绪状态的最高优先级线程便进入了运行状态
死亡：当线程的run方法结束或抛出一个未捕获的异常，那么线程便进入死亡状态
阻塞：如果处于运行状态的线程发出IO请求，它便进入了阻塞状态，当其等待的IO操作结束后，阻塞的线程便进入了就绪状态
等待：当处于运行状态的线程调用wait方式，线程便进入等待状态。它将按次序排在等待队列中，队列中的线程均是由于某个对象掉哦那个了wait方法才进入等待状态的当与某对象相关的另一个线程调用了notify方法是，那么等待该对象所有线程都回到就绪状态。
休眠：当程序调用一个正在运行的线程的sleep方法时，该线程便会进入休眠状态
多线程之间的通信
多个线程在处理同一个资源，但是处理的动作（线程的任务）不同，通过一定的手段使各个线程能有效的利用资源，而这种手段就是等待唤醒机制。
等待唤醒机制所涉及到的方法：
Wait（）：等待，将正在执行的线程释放其执行资格和执行权，并存储到线程池中
Notify（）：唤醒，唤醒线程池中被wait（）的线程，一次只能唤醒其中的任意一个
NotifyAll（）：唤醒全部，可以将线程池中的所有wait（）线程都唤醒
其实，所谓唤醒的意思就是让线程池中的线程具备执行资格，必须注意的是，这些方法都是在同步中有效的，同时这些方法在使用时必须标明所属锁，这样才可以明确出这些方法操作的到底是哪个锁上的线程
案例：生产者和消费者的问题
生产者生产馒头，消费者消费馒头….
当生产者发现没有馒头时，就会开始生产，生产完成后，叫消费者消费，如果发现有馒头，就会wait（）；
当消费者发现没有馒头时，就会wait（），当发现有馒头时，就消费，然后叫生产者继续生产。
JDK1.5后出现的新的接口和类：Lock：比同步函数和同步代码块要好一些，同步函数还是同步代码块所做的都是隐式的操作。并且，同步函数或者同步代码块使用的锁和监视器是同一个。
Lock接口：是将锁进行单独对象的封装，而且提供了对锁对象很多功能，比如：lock（）获取锁，unlock（）释放锁。Lock对锁的操作都是显示操作。所以它的出线要比同步函数或者同步代码块明确的多，更符合面向对象的思想
