一、概述

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();     
        }
    }