程序运行时，其实是CPU在执行程序的进程，为了提高工作效率一个进程可以有多个线程。
Java的多线程：
其实我们之前就见过Java的线程，main就是Java的一个线程，还有另一个条线程总是和main同时运行，那就是垃圾回收线程。
Java的线程有四种状态：
1，被创建：new Thread
2，运行（就绪）：JVM调用Thread的start方法执行Thread的run中的内容
3，冻结：sleep(毫秒)，wait()-notify()
4，消亡
Java可以通过继承Thread类和实现Runnable接口实现多线程技术。
通过继承Thread类实现多线程：
方法：
1，创建自定义的类继承Thread类
2，覆盖Thread类中的run方法
3，建立自定义的线程类的子类对象，即创建线程对象
4，调用start方法让JVM启动自定义线程（其实就是告诉JVM去运行自定义的run方法中的内容）
class DefinedThread extends Thread//自定义线程类继承Thread类
{
...
public void run()
{
...//复写Thread类中的run方法，定义该线程执行的内容
}
...
}
class MultThread
{
public static void main(String[] args)//main就是一个线程
{
DefinedThread dt = new DefinedThread();//创建线程对象
dt.start();//启动线程
}
}
通过实现Runnable接口实现多线程：
1，创建自定义的类实现Runnable接口
2，覆盖接口中的run方法
3，通过Thread类创建线程对象，并将自定义类的对象作为参数传递给Thread类的构造器
4，Thread类对象调用start方法开启线程
class DefinedThread implements Runnable//自定义类实现Runnable接口
{
...
public void run()
{
...//复写接口的run方法，定义该线程执行的内容
}
...
}
class MultThread
{
public static void main(String[] args)//main就是一个线程
{
DefinedThread dt = new DefinedThread();
Thread t = new Thread(dt);//把自定义类的子类对象当作参数传递给Thread构造器
t.start();//线程对象t调用start方法开启线程
}
}
Thread和Runnable之间的关系：
1，一个类只能继承一个类，而可以实现多个接口，就这点而言Thread有局限性，Runnable扩展性好
2，Thread对象调用Thread(Runnable run)或者Thread(Runnable run, String name)构造方法创建线程，使用的是同一个Runnable实例对象内的资源，就这点而言，Runnable适合资源共享。（当然继承Thread类，使用static变量也能共享资源，但这样比较麻烦而且static的生命周期长）
3，通过Thread类的定义 public class Thread extends Object implements Runnable ，可以看出Thread类其实也实现了Runnable接口，不过Thread中有start方法，而Runnable中没有，所以实现了Runnable的对象的run中的内容想要让JVM调用就必须把该对象传递给Thread的，由Thread的对象调用start方法启动线程从而运行run中的内容。
小例子：假如有4个窗口售票，票从1号到100号，我们先看继承Thread的MyThread类实现
class MultThread
{
public static void main(String[] args)
{ Thread t1 = new MyThread("窗口1");
Thread t2 = new MyThread("窗口2");
Thread t3 = new MyThread("窗口3");
Thread t4 = new MyThread("窗口4"); t1.start();
t2.start();
t3.start();
t4.start(); }
} class MyThread extends Thread
{
private static int tick = 1;
MyThread(String name)
{
super(name);
}
public void run()
{
while(tick<=100)
{
System.out.println(this.getName()+"售出"+tick+"号票");
tick++;
}
}
}通过实现了Runnable接口的MyR类
class MultThread
{
public static void main(String[] args)
{
MyR r = new MyR();
Thread t1 = new Thread(r,"窗口1");
Thread t2 = new Thread(r,"窗口2");
Thread t3 = new Thread(r,"窗口3");
Thread t4 = new Thread(r,"窗口4"); t1.start();
t2.start();
t3.start();
t4.start(); }
} class MyR implements Runnable
{
private int tick = 1;
public void run()
{
while(tick<=100)
{
System.out.println(Thread.currentThread().getName()+"售出"+tick+"号票");
tick++;
}
}
}但是对于双核或者多核的CPU来说这样会带来程序的风险，比如有可能出现1号票被卖了2次的情况，所以为了线程的安全性引出了同步的概念，这个笔记记录在下一节。