多线程

多线程介绍
学习多线程之前，我们先要了解几个关于多线程有关的概念。
进程：进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。

什么是多线程呢？即就是一个程序中有多个线程在同时执行。
通过下图来区别单线程程序与多线程程序的不同：
单线程程序：即，若有多个任务只能依次执行。当上一个任务执行结束后，下一个任务开始执行。如，去网吧上网，网吧只能让一个人上网，当这个人下机后，下一个人才能上网。
多线程程序：即，若有多个任务可以同时执行。如，去网吧上网，网吧能够让多个人同时上网。
例子：
public class Demo01 {
    //主线程 ：程序从上往下执行的过程  
    //javac编译Demo01
    //JVM 运行你的Demo01的main方法  找操作系统OS 开启线程
    //对于CPU来说就是有一条执行路径  运行方法main的这条路径有个名字叫"main"即主线程
    public static void main(String[] args) {
        System.out.println(0/0);
        method1();
    }
    public static void method1(){
        for(int i=0;i<1000;i++){
            System.out.println(i);
        }
    }
}

程序运行原理
分时调度
所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
抢占式调度
优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

创建新执行线程有两种方法。
一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。创建对象，开启线程。run方法相当于其他线程的main方法。
另一种方法是声明一个实现 Runnable 接口的类。该类然后实现 run 方法。然后创建Runnable的子类对象，传入到某个线程的构造方法中，开启线程。
方式一：Thread类

构造方法

常用方法

public class ThreadDemo extends Thread{
    public ThreadDemo(){}
    public ThreadDemo(String name){
        super(name);
    }
    public void run() {
        //System.out.println(getName());//获取线程名字
        for(int i=0;i<100;i++){
            try {
                sleep(1000);//休眠
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(i);
        }
    }
}
public class Test {
    //开线程的第一种方法
    //1.定义Thread子类，继承Thread  重写run方法
    //2.在测试类中，创建Thread子对象
    //3.用子类对象调用start方法  只能调用一次
    public static void main(String[] args) {
        //创建线程对象
        ThreadDemo td=new ThreadDemo();
        //开启线程   start:1.让线程执行  2.让JVM调用线程中的run方法
        td.start();
        /*for(int i=0;i<100;i++){
            System.out.println(i+"主");
        }*/
        //获取主线程名字
        Thread td2=Thread.currentThread();
        System.out.println(td2.getName());//main
    }
}
public class Test1 {
    public static void main(String[] args) {
        ThreadDemo td=new ThreadDemo("小野爹");
        //设置线程名称
        td.setName("小野猪");
        //开启线程
        td.start();
    }
}
public class Test2 {
    //休眠一秒执行
    public static void main(String[] args) {
        ThreadDemo td=new ThreadDemo();
        td.start();
    }
}
方式二：实现Runnable接口

接口中的方法

Thread类构造方法

public class MyRunable implements Runnable{
    public void run(){
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+" "+i);
        }
    }
}
public class Test {
    //第二种创建线程的方式
    //1.创建实现类，实习Runnable接口，重写run方法
    //2.在测试类中创建实现类对象，创建线程对象，将实现类对象传入线程对象的构造方法
    //3.用线程对象开启线程
    //高内聚，低耦合
    public static void main(String[] args) {
        //创建线程任务对象
        MyRunable mr=new MyRunable();
        //创建线程对象
        Thread t1=new Thread(mr);
        //开启线程
        t1.start();
        Thread t2=new Thread(mr);
        t2.start();
    }
}

线程的匿名内部类使用
public class Demo01 {
    //匿名内部类
    //new 抽象类接口(){
        //重写父类方法
    //}.子类独有的方法
    public static void main(String[] args) {
        //多态定义一个runnable实现类对象
        //来描述线程任务
        Runnable r=new Runnable(){
            public void run() {
                System.out.println("1");
            }
        };
        //创建线程
        Thread t=new Thread(r);
        //开启线程
        t.start();
        //也可以一句话实现
        new Thread(new Runnable(){
            public void run() {
                System.out.println("2");
            }
        }).start();
    }
}