多线程
进程：是一个正在执行的程序 。
线程：就是进程中的一个独立的控制单元，线程在控制进程的执行，一个进程中至少有 一个线程。
java VM 启动的时候会有一个进程java.exe。该进程中至少有一个负责java程序的执行，而且这个线程运行的代码存在于main方法中，该线程称之位主线程。
多线程的一个特性；随机性，谁抢到谁执行，至于执行对长，cpu说了算
创建新执行线程有两种方法。一种方法是将类声明为Thread的子类。该子类应重写Thread类的run方法。
1.如何在自定义的代码中，自定义一个线程呢？
通过对api的查找，java已经提供了对线程这类事物的描述，就是Thread类。
创建线程的第一种方式：继承Thread类。
步骤：
1.定义类继承Thread
2.复写Thread类中的run方法
目的；将自定义代码存储在run方法中，让线程运行
3.调用线程的start方法
该方法有两个作用：启动线程，调用run方法(存储要执行的代码)
为什么要覆盖run方法呢？
Thread 用于描述线程。
该类就定义了一个功能，用于存储线程要运行的代码。该存储功能就是run方法。
也就是说Thread类中的run方法，用于存储线程要运行的代码。
线程的五种状态：
被创建：start()
冻结状态（睡眠，等待）：放弃了执行资格 运行，阻塞可以到达
注：在同步代码中，wait()方法会释放锁，sleep()不会释放锁。
临时状态阻塞：具备执行资格，但没执行权 运行，冻结可以到达阻塞
运行：具备执行资格和执行权 创建，冻结，阻塞可以到达运行。
消亡：stop run()方法执行结束。运行-->消亡
创建线程的第二种方式(必须掌握)；实现Runnable 接口
步骤；
1.定义类实现Runnble接口
2.覆盖Runnable接口中的run方法
3.通过Thread类建立线程对象
4.将Runnble接口的子类对象作为实际参数传递给Thread类的构造函数；
为什么要将Runnable接口的子类对象传递给Thread的构造函数呢？
因为，Thread类要运行自定义run()的方法，而自定义的run方法所属的对象是Runnable接口的子类对象
Thread的构造函数可以接收Runnable的子类。所以要让线程去执行我们自己的run方法，就将run()所属的
对象传入。然后Thread会去调用对象中的run(),当然这就不是我们要管的了。
5.调用Thread类的start方法开启线程
实现方式和继承方式有什么区别?（重要）
实现的好处是：避免了单继承的局限性,如果对象本身已经继承了一个类，则无法继承再Thread
在定义线程时，建议使用是实现的方式式
两种方式的区别；
继承；线程代码存放在Thread子类run方法中
实现；线程代码存放在Runnable接口子类的run方法中
多线程出现安全问题原因；
当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行，导致共享数据的错误。 如：判断-结论。判断后线程交替，等线程在回来，往往出现问题。
解决办法；
对多条操作共享数数据的语句，只能让一个线程都执行完，在执行过程中其他线程不可以参与执行
就是同步代码块。
synchronized(对象)
{
需要被同步的代码
}
对象如同锁，持有锁的线程可以在同步中执行。
没有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。
火车上的卫生间--经典。
同步的前提；
1.必须要有两个或两个以上的线程。
2.必须是多个线程使用同一个锁。
必须保证同步中只能有一个线程在运行。
好处；解决多线程的安全问题
弊端；多线程需要判断，较为消耗资源。
如何找多线程问题；
1.明确哪些代码是多线程运行代码。、
2.明确共享数据
3.明确多线程运行代码中哪些语句是操作共享数据的。
同步函数和同步代码块
两者的区别：
同步函数的锁：同步函数所在的对象的this。
同步代码块：可以自己定义
如果同步函数被静态修饰，那么使用的锁是什么呢？本类的字节码文件
静态方法中不可以用this，静态进内存，内存中没有本类对象，
但是一定有本类对应的自节码文件对象。
单例设计模式。
*/
//饿汉式
class Single
{
private static final Single s = new Single();
private Single(){}
public static Single getInstance()
{
return s;
}
}
//懒汉式
class single
{
private static Single s = null;//懒汉式不可以使用final
private Single(){}
public static Single getInstance()//同步函数加了锁会很低效
{//双重判断，提高点效率
if(s==null){
synchrosized(Single.class)
{
if (s==null)//多条语句同时共享s
-->A
-->B，容易创建多个对象
s= new Single();
}
}
return s ;
}
}
懒汉式与饿汉式的区别：
1.懒汉式延时加载实例对象，什么用什么时候创建对象。
2.多线程访问出现易安全问题。什么问题，判断完s==null后，容易创建多个对象。
问题怎么解决？加同步函数和同步代码块，但是很低效，每次都得判断同步，
可以使用双重判断提高效率，在同步代码块外面再次判断。
同步代码块的琐是该类的字节码文件对象，因为getInstance是静态的，没有this.
死锁出现的原因：
同步中嵌套同步，而锁却不同
package cn.itcast;
public class Demo22死锁 {
/** 死锁的原因：同步中嵌套同步，而锁却不同 *
* 线程1拿到锁2，才释放锁1，线程2要拿到锁1，才释放锁2。
*/
public static void main(String[] args) {
new Thread(new DeadLock(false)).start();
new Thread(new DeadLock(true)).start();
}
}
class Lock{
public static final Lock Lock1 = new Lock();
public static final Lock Lock2 = new Lock();
}
class DeadLock implements Runnable{
boolean flag = false;
DeadLock(boolean flag) {
super();
this.flag = flag;
}
public void run() {
if(flag){
while(true){
synchronized (Lock.Lock1) {
System.out.println("if..a");
synchronized (Lock.Lock2) {
System.out.println("if..b");
}
}
}
}
else{
while(true){
synchronized (Lock.Lock2) {
System.out.println("else..a");
synchronized (Lock.Lock1) {
System.out.println("else..b");
}
}
}
}
}
}
来源：https://www.cnblogs.com/heimaprogramer/p/3773053.html