Java入门系列-21-多线程

什么是线程

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

线程是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();
    }
}

线程的生命周期

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

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

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

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

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

线程调度

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

线程调度常用方法

方法	说明
setPriority(int newPriority)	更改线程的优先级
static void sleep(long millis)	在指定的毫秒数内让当前正在执行的线程休眠
void join()	等待该线程终止
static void yield()	暂停当前正在执行的线程对象，并执行其他线程
void interrupt()	中断线程
boolean isAlive()	测试线程是否处于活动状态

线程优先级的设置

线程优先级由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);               
            }
        }
    }
}