Java多线程（Thread）

/*
    并发：两个或多个事件在同一时间段内交替执行
    并行：两个或多个事件同时执行

    在计算机中，程序存储在硬盘中(ROM),但所有的应用程序都需要
    进入到内存(RAM)中执行。

    进程：进入到内存的程序
    线程：点击程序的某个功能执行，就会开启一条应用程序到CPU的执行路径，
         CPU就可以通过这个路径执行功能，这个路径就叫线程
    多线程的好处：效率高，多个线程之间互不影响

    主线程：执行主方法（main）的线程

    单线程程序：java程序中只有一个线程
    执行从main方法开始，从上到下依次执行

 */
public class Demo01 {
    public static void main(String[] args){
        Person personOne = new Person("张三");
        personOne.run();

        Person personTwo = new Person("李四");
        personTwo.run();
    }
}

public class Person {
    private String name;

    public void run(){
        for (int i = 0; i < 20; i++) {
            System.out.println(name+"-->"+i);
        }
    }

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

创建多线程的第一种方式，使用Thread类

/*
    创建多线程程序的第一种方式：创建Thread类的子类
    java.lang.Thread类，是描述线程的类，我们想要实现多线程程序，就必须继承Thread类

    实现步骤：
        1.创建一个Thread类的子类
        2.在Thread类的子类中重写Thread类中的run方法，设置线程任务（开启线程要做什么？）
        3.创建Thread类的子类对象
        4.调用Thread类中的start方法，开启新的线程，执行run方法
            public void start()使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
     Java程序属于抢占式调度，线程优先级高先执行，同一个优先级，随机选择一个执行
 */
public class Demo01Thread {
    /*
        主方法中的for循环和MyThread类 两个线程随机性抢占执行
     */
    public static void main(String[] args) {
        //3.创建Thread类的子类对象
        MyThread myThread = new MyThread();
        //4.调用Thread类中的start方法，开启新的线程，执行run方法
        myThread.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("main"+i);
        }
    }
}

//1.创建一个Thread类的子类
public class MyThread extends Thread{
    //2.在Thread类的子类中重写Thread类中的run方法，设置线程任务（开启线程要做什么？）
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("run"+i);
        }
    }
}

Thread类的常用方法

/*
    主线程:main
    新线程:Thread-0，Thread-1，Thread-2

    Thread类常用方法：
    public String getName():获取当前线程名称
    public void start():启动线程
    public void run():此线程要执行的任务，在此处定义代码
    public static void sleep(long millis):指定毫秒暂停线程
    public static Thread currentThread():返回对当前正在执行的线程对象的引用。
 */
public class Demo01 {
    public static void main(String[] args){
        //调用Thread子类创建对象
        MyThread thread1 = new MyThread();

        //改变线程的名字
        thread1.setName("中国");

        thread1.start();//线程名称:Thread-0 //中国

        new MyThread("南京").start();//1 //南京
        new MyThread().start();//2

        //获取线程名称
        System.out.println(Thread.currentThread().getName());//main

        //模拟秒表
        for (int i = 0; i < 60; i++) {
            System.out.println(i);
            //使用Thread类中的sleep方法让程序睡眠一秒钟
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//Thread类子类
public class MyThread extends Thread{
    public MyThread(){
    }
    public MyThread(String name){
        super(name);//把线程名称传给父类，让Thread给子线程起名字
    }

    //重写Thread类中run方法，设置线程任务
    @Override
    public void run() {
        //获取线程名称
//        String name = getName();
//        System.out.println("线程名称:"+name);
//        System.out.println(Thread.currentThread());
//        System.out.println(getName());
        //链式编程
        System.out.println(Thread.currentThread().getName());
    }
}

创建多线程的第二种方式，使用Runnable接口

/*
    创建线程的第二种方式 实现Runnable接口（优先选择）
    步骤：
        1.定义Runnable接口的实现类，并重写该接口的run()方法
        2.创建Runnable实现类的实例，并将这对象作为在创建Thread时的一个参数来传递并启动
        3.调用Thread类的start()方法，执行新线程
 */
public class RunnableMain {
    public static void main(String[] args){
        //2.创建Runnable实现类的实例，并将这对象作为在创建Thread时的一个参数来传递并启动
        RunnableImpl runnable = new RunnableImpl();
        new Thread(runnable).start();//调用start()方法开启新线程，执行run()方法

    }
}

//创建Runnable接口的实现类
public class RunnableImpl implements Runnable{
    //重写run()方法，设置线程任务
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+i);
            try {
                Thread.sleep(1000);//休眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

使用匿名内部类方式创建线程

/*
    使用匿名内部类方式创建线程

    匿名：没有名字
    内部类：写在其他类内部

    作用：简化代码

    格式：
        new 父类/接口(){
            重写父类/接口中的方法
        }
 */
public class DemoInterfaceThread {
    public static void main(String[] args) {
        //使用Thread类
        new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println("熊瞎子" + i);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();

        //使用Runnable接口
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println("熊孩子" + i);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }
}