进程：是一个正在执行中的程序。
每一个进程执行都有一个执行顺序，该顺序就是一个执行路径，或者叫一个控制单元。
线程：就是进程中的一个独立的控制单元。
线程在控制着进程的执行。 一个进程中至少有一个线程。
例子：Java 虚拟机 启动的时候会有一个进程java.exe
该进程中至少有一个线程负责java程序的执行。
而且这个线程运行的代码存在于main方法中。
该线程称之为主线程。
扩展：其实更细节说明虚拟机，Jvm启动不止一个线程，还有负责垃圾回收机制的线程。
继承Thread类
步骤：
1，定义类继承Thread
2，重写Thread类中的run方法
目的：将自定义代码存储在run方法中，让线程运行。
3，调用该线程的start方法
该方法两个作用：启动线程，调用run方法
class Demo extends Thread //定义类继承Thread
{
//重写Thread类中的run方法:将自定义代码存储在run方法中，让线程运行
public void run() {
for(int i=0;i<100;i++)
System.out.println("Thread run:"+i+"线程");
}
}
public class ThreadDemo {
public static void main(String[] args)
{
Demo p=new Demo(); //创建一个线程
p.start(); //启动线程，调用run方法
//p.run(); //仅仅调用方法，而线程创建了，并未调用
for(int i=0;i<100;i++)
System.out.println("Hello Main:"+i);
}
}发现运行结果每一次都不同
因为多个线程都获取cpu的执行权，cpu执行到谁，谁就运行
明确一点，在某一个时刻，只能有一个程序在运行（）
cpu在做着快速的切换，以达到看上去是同时运行的效果。
我们可以形象把多线程的运行行为在互相抢夺CPU的执行权。
这就是多线程的一个特性，随机性，谁抢到谁执行，至于执行多长，CPU说的算
为什么要覆盖run方法呢？
Thread类用于描述线程。
该类就定义了一个功能，用于存储线程要运行的代码，该功能就是run方法。
也就是说Thred类中的run方法，是用于存储线程要运行的代码。
线程存在一个生命周期，由以下方法体现
线程的运行过程 
创建线程的第二种方式：实现Runnable接口
//创建线程的方式2
/*
1，定义类实现Runnable接口
2，覆盖Runnable接口中的run方法 ，将线程要运行的代码存放在该run方法中。
3，通过Runnable类建立线程对象
4，将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数
为什么要将Runnable接口的子类对象传递给Thread的构造函数
因为，自定义的run方法所属的对象是Runnable接口的子类对象。
所以要让线程去指定指定对象的run方法，就必须明确该run方法所属对象。
5，调用Thread类的start方法开启线程并调用Runnable接口子类的run方法
*/
class Demo2 implements Runnable //定义类实现Runnable接口
{
//覆盖Runnable接口中的run方法 ，将线程要运行的代码存放在该run方法中
public void run()
{
for(int i=0;i<160;i++)
{
System.out.print(Thread.currentThread().getName()+i+"\t");
}
}
}
class ThreadDemo2
{
public static void main(String[] args)
{
Demo2 d=new Demo2(); //创建一个Runnable接口的子类对象
Thread t=new Thread(d); //将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数
t.start();//开启线程并调用Runnable接口子类的run方法
for(int i=0;i<160;i++)
{
System.out.print("The main :"+i+"\t");
}
}
}实现方式和继承方式有什么区别呢？
实现方式的好处：避免了单继承的局限性。
在定义线程时，建立使用实现方式
区别：
Thread:线程代码存放在Thread子类run方法中。
Runnable,线程代码存放在接口的子类run方法中。
案例：模拟多窗口卖票流程
/*
需求：简单的卖票程序。
多个窗口同时买票。
*/
class Tickets implements Runnable //定义类实现Runnable接口
{
private int tick = 100; //定义票的数量为私有成员变量
//覆盖Runnable接口中的run方法 ，将买票过程的代码存放在该run方法中
public void run()
{
while(true)
{
if(tick>0)
{
System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--);
}
}
}
}
class TicketDemo
{
public static void main(String[] args)
{
Tickets t = new Tickets(); //创建一个Runnable接口的子类对象
//将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数
Thread t1 = new Thread(t);//创建了一个线程：模拟买票窗口1
Thread t2 = new Thread(t);//创建了一个线程：模拟买票窗口2
Thread t3 = new Thread(t);//创建了一个线程：模拟买票窗口3
Thread t4 = new Thread(t);//创建了一个线程：模拟买票窗口4
//开启线程并调用Runnable接口子类的run方法
t1.start();
t2.start();
t3.start();
t4.start();
}
}单例设计模式
设计模式：是解决某类问题行之有效的方法
单例设计模式：保证类在内存中的对象唯一性。
步骤：
1，定义私有并静态的本类对象。
2，私有化构造函数。
3，提供静态方法返回该对象
class Single2 //饿汉式
{
private static Single2 s = new Single2();
private Single2(){}
public static Single2 getSingle()
{
return s;
}
}
class Single //懒汉式
{
private static Single single=null;//定义私有并静态的本类对象
private Single(){} //私有化构造函数
//提供静态方法返回该对象
public static Single getInstance(){
if(single==null)
{//如果对象不存在，则新建一个对象
single=new Single();
}
return single;
}
}
public class ThreadTest2 {
public static void main(String[] args)
{
//保证类在内存中的对象唯一性，通过静态类的静态方法创建类的唯一对象
Single s1=Single.getInstance();
Single2 s2=Single2.getSingle();
}
}
