一、概述
1、进程
进程是指正在运行的程序，是系统进行资源分配和调用的独立单位。每一个进程都有它自己的内存空间和系统资源。
简单来说，进程就是一个程序
2、线程
在每一个进程内可以执行多个任务，而每一个任务我们就可以看成是一个线程。线程是程序的执行单元，执行路径，是程序使用CPU的最基本单位。
- 如果一个程序只有一条执行路径，那么该程序就是单线程程序；
- 如果一个程序有多条执行路径，那么该程序就是多线程程序。
简单来说：线程就是一个程序中的多个任务。因此，线程是依赖于进程而存在的。
3、分类
- 单进程单线程：一个人在一个桌子上吃饭；
- 单进程多线程：多个人在同一个桌子上一起吃饭——资源共享就会发生冲突抢夺；
- 多进程单线程：多个人每个人都在自己的桌子上吃饭；
在Windows系统中，由于打开新的进程占用的内存大，所以鼓励使用单进程多线程；在Linux系统中，由于打开新的进程占用内存小，所以鼓励使用多进程单线程。
4、多线程的意义
- 程序细分成几个功能相对独立的模块，防止其中一个功能模块阻塞导致整个程序卡死；
- 提高运行效率，比如多个核同时跑，或者单核里面，某个线程进行IO操作时，另一个线程可以同时执行。
5、单线程和多线程的区别
单线程：安全性高，但是效率低
多线程：安全性低，效率高
6、多线程的应用场景
- 迅雷开启多条进程一起下载
- QQ同时和多个人一起视频
- 服务器同时处理多个客户端请求
7、Java程序运行原理
Java命令会启动Java虚拟机，启动JVM，等于启动了一个应用程序，也就是启动了一个进程。该进程会自动启动一个“主线程”，然后主线程去调用某个类的main方法。所以main方法运行在主线程中。
二、多继承的实现方法
1、继承Thread类
步骤：
（1）自定义类继承Thread类；
（2）在自定义类中重写run()方法（run()方法中写需要被线程执行的代码）；
（3）创建对象；
（4）启动线程。
Thread成员方法：
String getName()：返回该线程的名称。
void setName(String name)：改变线程的名字，使之与参数name相同。
例：
//自定义类继承Thread类
public class MyThread extends Thread {
//在自定义类中重写run()方法
@Override
public void run(){
for (int i = 0; i < 100; i++) {
System.out.println(getName()+":"+i);
}
}
}
public class ThreadTest {
public static void main(String[] args) {
//创建对象
MyThread mt1 = new MyThread();
mt1.setName("张三");
MyThread mt2 = new MyThread();
mt2.setName("李四");
//启动线程
mt1.start();
mt2.start();
}
}
注意：
（1）多次启动一个线程是非法的，会报IllegalThreadStateException：非法的线程状态错误
（2）启动线程是start()方法，而不是run()方法，run()方法中放需要被线程执行的代码。
2、实现Runnable接口（大多数使用这个方法）
步骤：
（1）自定义类实现Runnable接口
（2）在自定义类中重写run()方法
（3）创建自定义类的对象
（4）创建Thread类的对象，并把c步骤创建的对象作为构造参数传递。
Thread的静态方法：
static Thread.currentThread()：返回当前线程对象
例：
//自定义类实现Runnable接口
public class MyThread implements Runnable {
// 在自定义类中重写run()方法
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
public class ThreadDemo {
public static void main(String[] args) {
//创建自定义类的对象
MyThread mt1 = new MyThread();
//创建Thread类的对象，并把c步骤创建的对象作为构造参数传递。
Thread t1 = new Thread(mt1);
t1.setName("张三");
t1.start();
MyThread mt2 = new MyThread();
Thread t2 = new Thread(mt2);
t2.setName("李四");
t2.start();
}
}
3、两种方法的区别
- 继承Thread
源码：由于子类重写了Thread类的run()，当调用start()方法时，直接找子类的run()方法；
优点：可以直接使用Thread类中的方法，代码简单；
缺点：如果已经有了父类，就不能使用这种方法。 - 实现Runnable接口
源码：构造函数中传入了Runnable的引用，成员变量记住了它，start()调用run()方法时内部判断成员变量Runnable的引用是否为空，不为空的话调用Runnable的run()方法；
优点：即使自己定义的线程类有了父类也没关系，还可以实现接口，并且可以同时实现多个接口；
缺点：不能直接使用Thread中的方法，如果使用需要先获取到线程对象后，才能得到Thread类中的方法，代码复杂。
三、应用：模拟火车站售票
1、分析
首先需要有火车票的总数量（假设为100张），每售出一张则数量减一；当火车票的数量小于1的时候，停止售票；使用多线程模拟多个窗口进行售票。
public class TicketThread implements Runnable{
//定义车票总量
int tickets = 100;
@Override
public void run() {
while(true){
//当火车票的数量小于1的时候，停止售票
if(tickets > 0){
//售票员中间可能会休息一下
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
//售票成功，剩余票数减一
tickets--;
System.out.println(Thread.currentThread().getName() + "卖出一张票，还剩"+tickets+"张");
}
}
}
}
注意：
子类重写父类方法时，如果父类没有抛出异常，那么子类也不能抛出，只能用try......catch处理异常
2、火车站售票出现的问题
我们在运行上面的代码时会发现，有时候会出现两个2，有时候剩余票数为-1，这是怎么回事呢？
我们先来介绍一个概念——寄存器：
寄存器是CPU内部用来存放数据的一些小型存储区域，用来暂时存放参与运算的数据和运算结果。
线程之间信息共享是在内存中，但是变量是读取到寄存器中来进行操作的。线程每次访问变量的时候，有时候会贪图便宜直接使用寄存器中的值，但是这个可能已经和最新的内存中得到的值不一样了。这是就会出现以上不可预期的问题。
通俗的讲就是，线程1在剩余两张票的时候，将内存更新为2，这时候线程1,2同时启动，都读取到了这个2到寄存器中，然后就会出现这样的问题。
3、解决方法
为了解决这样的问题，我们需要在每个线程更改数据后，将这些数据同步，使别的线程知道这个数据发生了改变。这里需要用到synchronized关键字。
synchronized:同步（锁），可以修饰代码块和方法，被修饰的代码块和方法一旦被某个线程访问， 则直接锁住，其他的线程将无法访问。
（1）同步代码块
synchronized(锁对象){
}
注意：锁对象需要被所有的线程所共享，一般使用类名.class
public class ThreadTest1 extends Thread {
static int tickets = 100;
@Override
public void run() {
while (true) {
synchronized (ThreadTest1.class) {
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
tickets--;
System.out.println(getName() + "售出一张车票，剩余" + tickets + "张");
}
}
}
}
}
public class Test1 {
public static void main(String[] args) {
ThreadTest1 tt1 = new ThreadTest1();
tt1.setName("售票处1");
tt1.start();
ThreadTest1 tt2 = new ThreadTest1();
tt2.setName("售票处2");
tt2.start();
ThreadTest1 tt3 = new ThreadTest1();
tt3.setName("售票处3");
tt3.start();
}
}
（2）同步方法
如果一个方法中的代码都有问题,就可以使用synchronized来修饰方法,这个方法就变成了同步方法。这样就会把整个方法加上锁,一个线程访问之后,其他线程都无法访问.这样就实现了安全性。
注意：
非静态同步方法的锁对象是this
静态的同步方法的锁对象是当前类的字节码对象
public class MyThread implements Runnable {
int num = 1000;
@Override
public void run() {
while (true) {
method();
}
}
public synchronized void method() {
if (num > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
num--;
System.out.println(Thread.currentThread().getName() + "售出一张车票,剩余" + num + "张");
}
}
}
public class Test {
public static void main(String[] args) {
MyThread mt = new MyThread();
Thread t1 = new Thread(mt);
t1.setName("售票处1");
t1.start();
Thread t2 = new Thread(mt);
t2.setName("售票处2");
t2.start();
Thread t3 = new Thread(mt);
t3.setName("售票处3");
t3.start();
}
}
