多线程创建的方式

一、了解程序，进程和线程
程序：是为了完成特定任务，用特定语言编写的一组指令的集合，是一段静态代码。
进程：是程序的一次执行，是进行中的程序，是动态的，有生命周期的。
线程：是进程的细化，是程序内部的一条执行路径，每个进程都拥有独立的栈和程序计数器，而多个进程共享一个堆和方法区。

二、当我们的程序在运行过程中需要执行两个或者多个任务，实现一些需要等待的任务，如用户输入，文件读写等，还有需要一些后台的运行程序的时候，都需要用到多线程。

三、多线程创建的两种常用方式：
方式1 . 继承Thread类

public class ThreadTest {
    public static void main(String[] args) {
        // 3.创建Thread子类的类的对象
        myThread myThread = new myThread();
        // 4.调用start()方法
        myThread.start();
        System.out.println("这是主线程的执行");
    }
}
// 1.继承Thread类，
class myThread extends Thread{
// 2.重写run方法，run方法中是该线程执行的操作
    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
            if(i%2==0){
                System.out.println("输出的偶数是:"+i);
            }
        }
    }
}

方式2 . 实现Runnable接口

public class Threadtest1 {
    public static void main(String[] args) {
        // 3. 实例化接口类对象
        myThread myThread = new myThread();
        // 4.创建Thread类的对象，传递对象之
        Thread thread = new Thread(myThread);
        thread.setName("线程一");
        // 5.调用start()方法
        thread.start();
        // 再启动一个线程，遍历100以内的偶数
        Thread thread1=new Thread(myThread);
        thread1.setName("线程二");
        thread1.start();
    }
}
// 1.通过类实现Runnable接口
class  myThread implements Runnable{
// 2.重写run方法，该方法中是执行线程的操作
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i%2==0){                
            System.out.println(i+Thread.currentThread().getName());
            }
        }
    }
}

四、通过继承方式和实现接口方式，实现多窗口卖票（这里暂不考虑线程安全问题）

public class WindowTest5 {
    public static void main(String[] args) {
        // 实例化窗口一的对象
        SaleTicket saleTicket = new SaleTicket();
        // 实例化窗口二的对象
        SaleTicket saleTicket1=new SaleTicket();
        // 实例化窗口三的对象
        SaleTicket saleTicket2=new SaleTicket();
        // 窗口一卖票
        saleTicket.start();
        // 窗口二卖票
        saleTicket1.start();
        // 窗口三卖票
        saleTicket2.start();
    }
}
class SaleTicket extends Thread{
// 这里需要使用static静态变量，是创建的对象共享这同一静态变量，100张票
    private static int ticket=100;
    @Override
    public void run() {
    // 重写run方法
       while (true){
            if (ticket>0){
                System.out.println(Thread.currentThread().getName()+"卖票，票号为"+ticket);
                ticket--;
            }else{
                break;
            }
        }
    }
}

class SaleTicket implements Runnable{
    // 假设这里的车票数为100张
    private  int ticket=100;
    @Override
    public void run() {
    // 重写run方法，使用while循环
        while (true){
            if (ticket>0){
              System.out.println(Thread.currentThread().getName()+"卖票，票号为"+ticket);
              ticket--;
            }else{
                break;
            }
        }
    }
}
    public class windowTest {
    public static void main(String[] args) {
        // 实例化接口类的对象
        SaleTicket saleTicket=new SaleTicket ();
        // 创建Thread类的对象，传递对象值
        Thread thread=new Thread(saleTicket);
        Thread thread1=new Thread(saleTicket);
        Thread thread2=new Thread(saleTicket);
        // 线程一
        thread.start();
        // 线程二
        thread1.start();
        // 线程三
        thread2.start();
    }
}

总结：在开发中我们应该优先选择通过实现Runnable接口的方式。实现接口没有类的单继承的局限，同时更适合处理多个线程共享数据的情况，而在继承中则需要static静态对象。