一、多线程的基本概念

1、程序

它以某些程序设计语言编写，运行于某种目标结构体系上。

如：程序就像数学一样，要有一个懂数学的人，同时也会用计算的人去理解、分析、得出结果。以数学为基础的计算机要经过编译、链接而成为人难以解读，但可被计算机所解读的格式，然后运行。

2、进程

进程是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。

3、线程

若一个进程同一时间并行执行多个线程，就是支持多线程的

如：

? ? ? ? 5个人去抢篮球，抢到的几率都一样，但不是都能抢到。（随机性）

1、为什么使用多线程

多线程可以提高效率。

如：

? ? ? ? 一个寺庙有10个和尚，假设他们一天要喝十桶水，如果一个和尚去挑水来回一共花费30分钟，那么他挑完10桶水一共需要5个小时。但如果同时5个和尚去挑水，每个人挑一桶水，假设来回时间不变那么一共需要1个小时，时间大幅缩小。及多个线程可以提高效率。

2、何时使用多线程

? ? ? ? 1、程序需要同时执行两个或多个任务。

? ? ? ? 2、程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、搜索等。

? ? ? ? 3、需要一些后台运行的程序时。

二、?线程的创建和使用

? ? ? ? 1.Thread类

????????构造器：

????????Thread()：创建新的Thread对象

????????Thread(String threadname)：创建线程并指定线程实例名

????????Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口中的run方法

????????Thread(Runnable target, String name)：创建新的Thread对象

? ? ? ? 2.1创建线程的方法一(继承)

????????创建线程的步骤：

????????1、定义一个类继承Thread。

????????2、重写run方法。

????????3、创建线程对象。

????????4、调用start方法，开启线程并让线程执行，同时还会告诉jvm去调用run方法。

public class Dome1 {
    public static void main(String[] args) {
        //3、创建线程对象。
        Subclass sub = new Subclass();
        //4 调用start方法，开启线程并让线程执行，同时还会告诉jvm去调用run方法。
        sub.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("mian方法"+i);
        }
    }
}
//1、定义一个类继承Thread。
class Subclass extends Thread{
    @Override
    //2、重写run方法。
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName()+"正在运行"+i);
        }
    }
}

这里可以清晰的看见每一步的执行步骤。看看运行结果。

我们可以看见程序还是先执行mian方法中的循环，再去执行线程中的循环。mian方法便是主方法的训话，而Thread-0就是线程的循环。

????????2.2创建线程的方法二(接口)

????????1、定义子类，实现Runnable接口。

????????2、子类中重写Runnable接口中的run方法。

????????3、通过Thread类含参构造器创建线程对象。

????????4、将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。

????????5、调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。

public class Dome2 {
    public static void main(String[] args) {
        //3、通过Thread类含参构造器创建线程对象。
        Subclas sub = new Subclas();
        //4、 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。
        Thread thr = new Thread(sub);
        //给多线程命名为线程1
        thr.setName("线程1");
        //5、 调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。
        thr.start();
        //main函数输出奇数
        for (int i = 1; i <= 100; i++) {
            if (i%2!=0){
                System.out.println(Thread.currentThread().getName()+"输出的奇数是"+i);
            }
        }
    }
}
//1、定义子类，实现Runnable接口。
class Subclas implements Runnable{
    @Override
   // 2、子类中重写Runnable接口中的run方法。
    public void run() {
        //多线程输出偶数
        for (int i = 1; i <= 100; i++) {
            if (i%2==0){
                System.out.println(Thread.currentThread().getName()+"输出的偶数是:"+i);
            }
        }
    }
}

可以看到两种方式都是围绕着Thread和Runnable，继承Thread类把run()写到类中，Runnable接口是把run()方法写到接口中然后再用Thread类来包装, 两种方式最终都是调用Thread类的start()方法来启动线程的。我们来看看结果

?可以看见线程1和main方法是在互相抢夺线程，并且输出是随机不规律的。

? ? ? ? 3、多线程的应用

? ? ? ? 例题：火车票问题

????????????????既然了解多线程了，那么来看看多线程在程序中的应用，来看看下面的代码。

public class Dome3 {
    public static void main(String[] args) {
        //创建线程任务对象
        Subcla thr = new Subcla();
        //创建三个窗口对象              同时卖票
        new Thread(thr,"线程1").start();
        new Thread(thr,"线程2").start();
        new Thread(thr,"线程3").start();
    }
}
class Subcla extends Thread{
    /*
     * 执行卖票操作
     */
    //定义100张票(静态)
    public static int inp = 100;
    @Override
    public void run() {
        //每个窗口卖票的操作
        super.run();
        while (true){
            if (inp>0){
                                        获取当前线程对象的名字
                System.out.println(Thread.currentThread().getName()+"售卖的车票是"+inp--);
            }else
                break;
        }
    }
}

假设一共有100张票，三个窗口去卖这100张票。三个窗口去卖这100张票就会比一个窗口卖出的速度提高了两倍，看看结果。