什么是线程

在操作系统中，一个应用程序的执行实例就是进程，进程有独立的内存空间和系统资源，在任务管理器中可以看到进程。

线程是CPU调度和分派的基本单位，也是进程中执行运算的最小单位，可完成一个独立的顺序控制流程，当然一个进程中可以有多个线程。

多线程：一个进程中同时运行了多个线程，每个线程用来完成不同的工作。多个线程交替占用CPU资源，并非真正的并行执行。

使用多线程能充分利用CPU的资源，简化编程模型，带来良好的用户体验。

一个进程启动后拥有一个主线程，主线程用于产生其他子线程，而且主线程必须最后完成执行，它执行各种关闭动作。

在Java中main()方法为主线程入口，下面使用 Thread 类查看主线程名。

public class MainThread {
    public static void main(String[] args) {
        //获取当前线程
        Thread t=Thread.currentThread();
        System.out.println("当前线程名字："+t.getName());
        //自定义线程名字
        t.setName("MyThread");
        System.out.println("当前线程名字："+t.getName());
    }
}

创建线程

在Java中创建线程有两种方式
1.继承 java.lang.Thread 类
2.实现 java.lang.Runnable 接口

1.继承 Thread 类创建线程

(1)定义MyThread类继承Thread类

(2)重写run()方法，编写线程执行体

public class MyThread extends Thread{

    //重写run方法
    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

(3)创建线程对象，调用start()方法启动线程

public class TestMyThread {

    public static void main(String[] args) {
        MyThread myThread=new MyThread();
        //启动线程
        myThread.start();
    }
}

多个线程同时启动后是交替执行的，线程每次执行时长由分配的CPU时间片长度决定

修改 TestMyThread.java 观察多线程交替执行

public class TestMyThread {

    public static void main(String[] args) {
        MyThread myThread1=new MyThread();
        MyThread myThread2=new MyThread();
        myThread1.start();
        myThread2.start();
    }
}

多运行几次观察效果

启动线程能否直接调用 run()方法？

不能，调用run()方法只会是主线程执行。调用start()方法后，子线程执行run()方法，主线程和子线程并行交替执行。

2.实现 Runnable 接口创建线程

(1)定义MyRunnable类实现Runnable接口

(2)实现run()方法，编写线程执行体

public class MyRunnable implements Runnable{
    //实现 run方法
    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

(3)创建线程对象，调用start()方法启动线程

public class TestMyRunnable {

    public static void main(String[] args) {
        Runnable runnable=new MyRunnable();
        //创建线程，传入runnable
        Thread t=new Thread(runnable);
        t.start();
    }
}

线程的生命周期

graph LR
A(创建状态) -->|启动线程| B(就绪状态)
C(阻塞状态) -->|阻塞解除| B
D(运行状态) -->|释放CPU资源| B
B -->|获得CPU资源| D
D -->|等待用户输入线程休眠等| C
D --> E(死亡状态)

创建状态：线程创建完成，比如 MyThread thread=new MyThread

就绪状态：线程对象调用 start() 方法，线程会等待CPU分配执行时间，并没有立马执行

运行状态：线程分配到了执行时间，进入运行状态。线程在运行中发生礼让 (yield) 会回到就绪状态

阻塞状态：执行过程中遇到IO操作或代码 Thread.sleep()，阻塞后的线程不能直接回到运行状态，需要重新进入就绪状态等待资源的分配。

死亡状态：自然执行完毕或外部干涉终止线程

线程调度

线程调度指按照特定机制为多个线程分配CPU的使用权

线程调度常用方法

线程优先级的设置

线程优先级由1~10表示，1最低，默认有限级为5。优先级高的线程获得CPU资源的概率较大。

public class TestPriority {

    public static void main(String[] args) {
        Thread t1=new Thread(new MyRunnable(),"线程A");
        Thread t2=new Thread(new MyRunnable(),"线程B");
        //最大优先级
        t1.setPriority(Thread.MAX_PRIORITY);
        //最小优先级
        t2.setPriority(Thread.MIN_PRIORITY);
        t1.start();
        t2.start();
    }
}

线程休眠

让线程暂时睡眠指定时长，线程进入阻塞状态，睡眠时间过后线程会再进入可运行状态。

休眠时长以毫秒为单位，调用sleep()方法需要处理 InterruptedException异常。

public class TestSleep {
    
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            System.out.println("第 "+i+" 秒");
            try {
                //让当前线程休眠1秒
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

强制运行

使用 join() 方法实现，可以认为是线程的插队，会先强制执行插队的线程。

public class JoinThread implements Runnable{

    @Override
    public void run() {
        for (int i = 1; i <=10; i++) {
            System.out.println("线程名："+Thread.currentThread().getName()+" i:"+i);
        }
        System.out.println("插队线程执行完毕！");
    }    
}

public class TestJoin {

    public static void main(String[] args) {
        Thread joinThread=new Thread(new JoinThread(),"插队的线程");
        //启动后与主线程交替执行
        joinThread.start();
        for (int i = 1; i <= 10; i++) {
            if (i==5) {
                try {
                    System.out.println("====开始插队强制执行====");
                    joinThread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("线程名："+Thread.currentThread().getName()+" i:"+i);
        }
        System.out.println("主线程执行完毕！");
    }
}

最一开始执行，主线程 main 和 "插队的线程"是交替执行。当主线程的循环到第5次的时候，调用 "插队的线程"的join方法，开始强制执行"插队的线程"，待"插队的线程"执行完后，才继续恢复 main 线程的循环。

线程礼让

使用 yield() 方法实现，礼让后会暂停当前线程，转为就绪状态，其他具有相同优先级的线程获得运行机会。

下面我们实现Runnable接口，在run方法中实现礼让，创建两个线程，达到某种条件时礼让。

public class YieldThread implements Runnable{

    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            System.out.println("线程名："+Thread.currentThread().getName()+" i:"+i);
            //当前线程执行到5后发生礼让
            if (i==5) {
                System.out.println(Thread.currentThread().getName()+" 礼让：");
                Thread.yield();
            }
        }
    }
}

public class TestYield {

    public static void main(String[] args) {
        Thread t1=new Thread(new YieldThread(),"A");
        Thread t2=new Thread(new YieldThread(),"B");
        t1.start();
        t2.start();
    }
}

只是提供一种可能，不能保证一定会实现礼让

线程同步

首先看一个多线共享同一个资源引发的问题

仓库有10个苹果，小明、小红、小亮每次可以从仓库中拿1个苹果，拿完苹果后仓库中的苹果数量-1。

先编写仓库资源类，实现接口

//这个实现类将被多个线程对象共享
public class ResourceThread implements Runnable{
    private int num=10;
    @Override
    public void run() {
        while(true) {
            if (num<=0) {
                break;
            }
            num--;
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"拿走一个，还剩余："+num);
        }
    }
}

编写测试类，创建两个线程对象，共享同一个资源

public class TestResource {

    public static void main(String[] args) {
        ResourceThread resource=new ResourceThread();
        //使用同一个Runnable实现类对象
        Thread t1=new Thread(resource,"小明");
        Thread t2=new Thread(resource,"小红");
        Thread t3=new Thread(resource,"小亮");
        t1.start();
        t2.start();
        t3.start();
    }
}

运行后我们发现，每次拿完苹果后的剩余数量出现了问题，使用同步方法可以解决这个问题。

语法：

访问修饰符 synchronized 返回类型 方法名(参数列表){
    ……
}

synchronized 就是为当前的线程声明一个锁

修改 ResourceThread.java 实现同步

//这个实现类将被多个线程对象共享
public class ResourceThread implements Runnable{
    private int num=10;
    private boolean isHave=true;
    @Override
    public void run() {
        while(isHave) {
            take();
        }
    }
    //同步方法
    public synchronized void take() {
        if (num<=0) {
            isHave=false;
            return;
        }
        num--;
        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"拿走一个，还剩余："+num);
    }
}

实现同步的第二种方式同步代码块

语法：

synchronized(syncObject){
    //需要同步的代码
}

syncObject为需同步的对象，通常为this

修改 ResourceThread.java 改为同步代码块

//这个实现类将被多个线程对象共享
public class ResourceThread implements Runnable{
    private int num=10;
    private boolean isHave=true;
    @Override
    public void run() {
        while(isHave) {
            synchronized(this) {
                if (num<=0) {
                    isHave=false;
                    return;
                }
                num--;
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"拿走一个，还剩余："+num);                
            }
        }
    }
}