1.线程概述

并发：指两个或多个事件在同一时间段内发生。

并行：指两个或多个事件在同一时刻发生（同时发生）。

进程：每一个独立执行的程序都是一个进程，每一个进程都有一个独立的内存空间。

线程：它是进程中的一个执行单元，负责当前进程的程序执行。一个进程至少有一个线程。

【说明】：从表面上看，多线程是同时并发执行的，但是它们和进程一样，也是由CPU控制并轮流执行的，只不过CPU运行速度非常快，故而给人同时执行的感觉。

线程的调度：(1)分时调度：所有线程轮流使用CPU使用权，平均分配每个线程占用CPU的时间。(2)抢占式调度：存在线程优先级。

2.线程创建概述

Java中，有3种常见创建线程的方法：(1)通过继承 Thread 类本身, (2)通过实现 Runnable 接口, (3)通过 Callable 和 Future 创建线程。 看看平时单线程程序的运行过程：

class Person{
    private  String name;

    public Person(){
    }

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

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

public class demo {
    public static void main(String[] args){
        Person p1 = new Person("小强");
        p1.run();
        Person p2 = new Person("旺财");
        p2.run();
    }
}

小强--->0
小强--->1
小强--->2
小强--->3
小强--->4
旺财--->0
旺财--->1
旺财--->2
旺财--->3
旺财--->4

3.方法一：继承 Thread 类

package Multithreading;
/*
    创建线程方法一：通过继承Thread 类本身
*/

// 1.定义一个继承Thread的线程类
class MyThread1 extends Thread{
    // 2.重写Thread类的run（）方法
    @Override
    public void run(){
        for (int i = 0; i < 5; i++){
            System.out.println("run:" + i);
        }
    }
}

public class Dem01 {
    public static void main(String[] args) {
        // 3.创建Thread子类实例对象MyThread1
        MyThread1 mt = new MyThread1();
        // 4.通过start（）方法启动线程
        mt.start();

        // 主线程main中的执行语句
        for (int i = 0; i < 5; i++){
            System.out.println("main:" + i);
        }
    }
}

main:0
run:0
main:1
run:1
main:2
run:2
main:3
run:3
main:4
run:4

4.方法二： 实现 Runnable 接口

package Multithreading;
/*
    创建线程方法二：通过实现 Runnable接口
    优点：
        1.避免了单继承的局限性
        2.增强程序扩展性，降低程序的耦合性
            设置线程任务与开启线程任务分离
*/

// 1.创建一个Runnable接口的实现类
class RunnableImpl implements Runnable {
    // 2.在Runnable实现类中重写run（）方法,设置线程任务
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}

public class Demo04 {
    public static void main(String[] args) {
        // 3.创建一个Runnable接口的实现类对象
        RunnableImpl r = new RunnableImpl();
        // 4.创建一个Thread对象,构造方法中传递Runnable接口实现类对象
        Thread t = new Thread(r);
        // 5.调用Thread方法中的start（）方法
        t.start();

        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}

main--->0
Thread-0--->0
main--->1
Thread-0--->1
main--->2
Thread-0--->2
main--->3
Thread-0--->3
main--->4
Thread-0--->4

5.方法三：通过 Callable 和 Future

6.其他方法：利用匿名内部类

package Multithreading;
/*
    其他方法：利用匿名内部类
*/
public class Demo05 {
    public static void main(String[] args) {
        new Thread(){
          @Override
          public void run(){
              for (int i = 0; i < 3; i++) {
                  System.out.println(Thread.currentThread().getName() + "--->" + "a");
              }
          }
        }.start();

        Runnable r = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 3; i++) {
                    System.out.println(Thread.currentThread().getName() + "--->" + "b");
                }
            }
        };
        new Thread(r).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 3; i++) {
                    System.out.println(Thread.currentThread().getName() + "--->" + "c");
                }
            }
        }).start();
    }
}

Thread-1--->b
Thread-0--->a
Thread-2--->c
Thread-0--->a
Thread-1--->b
Thread-0--->a
Thread-2--->c
Thread-1--->b
Thread-2--->c

7.获取线程名称

获取线程名称的方法主要有2种：

1.利用Thread类中的getName（）方法

package Multithreading;
/*
    获取线程名称的方法：
        1.利用Thread类中的getName（）方法
*/

class MyThread extends Thread{
    @Override
    public void run(){
        // 获取线程名称
        String name = getName();
        System.out.println(name);
    }
}

public class Demo02 {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        mt.start();
    }
}

Thread-0

2.利用static Thread currentThread（）与getName（）获取当前正在执行的线程名称

/*
    获取线程名称的方法：
        2.利用static Thread currentThread（）与getName（）获取当前正在执行的线程名称
*/
class MyThread extends Thread{
    @Override
    public void run(){
        // 获取线程名称
        Thread t = Thread.currentThread();
        System.out.println(t);
        String name = t.getName();
        System.out.println(name);
    }
}

Thread[Thread-0,5,main]
Thread-0

3.利用链式编程：获取当前正在执行的线程名称

public class Demo02 {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName());
    }
}

main

8.sleep()方法

package Multithreading;
/*
    利用sleep（）方法每1s打印一次
*/
public class Demo03 {
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 60; i++){
            System.out.println(i);
            Thread.sleep(1000);
        }
    }
}