何为线程?

简单来说,打开你电脑的任务管理器，在进程选项卡中，可以看到你电脑上一个一个正在运行的程序，我们可以把这里的每一个程序理解为一个进程，而进程是受系统管理的基本单元。

那么啥是线程呢？我们可以理解为一个进程里面包含了很多个线程。而一个线程可以当作这个进程的一个子任务。就比如说你的微信，在你刷朋友圈的同时，也可以接收消息，这就是两个线程在运行。

我们为什么要用线程呢？我们来看看下面这张图。

那么我们用了线程以后呢？

由图可知，任务二并不需要按照我们平常所写地Java代码从上到下执行，需要等待10S，等任务一执行完毕以后才执行任务二，线程带来的好处显而易见，能够极大地提升程序地运行效率。简单来说，线程是异步的。

实现多线程编程的方式主要有两种，一种是继承（extends）Thread类，一种是实现Runnable接口，h还有一种是使用FutureTask的方式创建。

这里举一个例子，如果你是商家，有自己的销售平台，当库存量为n时，是不是每当有人下单m件商品时，库存量就得减少m呀。那么在这样的情况下，用线程编程是怎么实现的呢？

线程Thread可以调用currentThread()方法的getName()获取到当前线程的名字。接下来我们来看看这段代码。

package com.gantiexia.threadTest;
/** * @author GanTieXia * @date 2021/9/17 20:52 */
public class ShareVariableThread extends Thread{
    public int count = 5;
    @Override
    public void run(){
        // 获取到线程拿到count时的值并保存下载做输出使用
        int beforeCount = count;
        // 操作count
        count--;
        // 输出
        System.out.println("线程操作前count的值：" + beforeCount + "。线程" + Thread.currentThread().getName() + "操作后的值：" + count);
    }
    public static void main(String[] args) {
        // 创建五个线程
        Thread a = new ShareVariableThread();
        Thread b = new ShareVariableThread();
        Thread c = new ShareVariableThread();
        Thread d = new ShareVariableThread();
        Thread e = new ShareVariableThread();
        // 启动线程
        a.start();
        b.start();
        c.start();
        d.start();
        e.start();
    }
}

相信大家在看这部分的代码时，肯定会预想到答案，count肯定会一次递减输出，但是真的是这样吗，我们运行看一看。

如图，每一个线程在被创建的时候，其实都是new了一个本类的对象，也就是说，count在每个线程中都出现了一次，每个线程都在自己减少自己的count的值，并没有做到变量共享的情况。

于是我们把代码改成这样：

package com.gantiexia.threadTest;
import com.gantiexia.myhashmap.ThreadAa;
/** * @author GanTieXia * @date 2021/9/17 20:51 */
public class PrivateVariableThread extends Thread{
    private int count = 5;
    @Override
    public void run(){
        // 获取到线程拿到count时的值并保存下载做输出使用
        int beforeCount = count;
        // 操作count
        count--;
        // 输出
        System.out.println("线程操作前count的值：" + beforeCount + "。线程" + Thread.currentThread().getName() + "操作后的值：" + count);
    }
    public static void main(String[] args) {
        PrivateVariableThread thread = new PrivateVariableThread();
        // 创建五个线程
        Thread a = new Thread(thread,"A");
        Thread b = new Thread(thread,"B");
        Thread c = new Thread(thread,"C");
        Thread d = new Thread(thread,"D");
        Thread e = new Thread(thread,"E");
        // 启动线程
        a.start();
        b.start();
        c.start();
        d.start();
        e.start();
    }
}

看到这里，那这样总是在共享变量了吧？答案会不会如我们锁期待的一样呢？我们来看看。

可以看到，得到的结果并不是我们想要的结果，线程A和线程B操作后的count值都为3了，虽然每次线程锁拿到的值都是正确的，但是输出的时候却不正确了，这就造成了非线程不安全的问题，这是为什么呢？

在JVM中，count–的操作步骤要分为这几步：
①获取到count的值。
②计算count–的值。
③对count重新赋值。

在这三个步骤执行的过程中，如果有多个线程同时访问，那么一定会出现非线程安全的问题。这个时候，我们就要在run()方法上加上我们的synchronized锁。

@Override
    synchronized public void run(){
        // 获取到线程拿到count时的值并保存下载做输出使用
        int beforeCount = count;
        // 操作count
        count--;
        // 输出
        System.out.println("线程操作前count的值：" + beforeCount + "。线程" + Thread.currentThread().getName() + "操作后的值：" + count);
    }

这样我们的运行结果又是怎样的呢？

那么此刻，我们就得到了我们想要的结果了。

实例演示

再回到我们刚才上面所讲到的问题：

这里举一个例子，如果你是商家，有自己的销售平台，当库存量为n时，是不是每当有人下单m件商品时，库存量就得减少m呀。那么在这样的情况下，用线程编程是怎么实现的呢？

我们来用线程简单模拟一下这个情景：

package com.gantiexia.threadTest;
/** * @author GanTieXia * @date 2021/9/17 22:48 */
public class SaleThread extends Thread{
    // 商品初始库存量为100件
    public int INVENTORY_COUNT = 100;
    @Override
    synchronized public void run(){
        // 获取到线程拿到count时的值并保存下来做输出使用
        int beforeCount = INVENTORY_COUNT;
        // 假设每个人的下单数量为[1,10]件之间
        int saleCount = (int) ((Math.random()*10) + 1);
        // 减少库存量
        INVENTORY_COUNT = INVENTORY_COUNT - saleCount;
        // 库存量大于0的时候才可以继续卖出
        if(INVENTORY_COUNT >= 0){
            // 输出
            System.out.println("剩余库存量：" + beforeCount + "件。顾客" + Thread.currentThread().getName() + "购买"+ saleCount +"件商品。剩余库存量：" + INVENTORY_COUNT + "件。");
        } else if(INVENTORY_COUNT < 0) {
            // 当库存不够时
            System.out.println("剩余库存量：" + beforeCount + "件，顾客需求量："+ saleCount + "件。库存不足，请尽快补充库存！");
            // 销售不成功，库存量为这个顾客操作时的剩余库存量
            INVENTORY_COUNT = beforeCount;
        }
    }
    public static void main(String[] args) {
        SaleThread thread = new SaleThread();
        // 假设此处有26个顾客产生了购买行为
        for(int i=0;i<26;i++) {
            // 顾客姓名我们用大写英文字母表示
            char customer = (char)('A'+i);
            // 转换成字符转用来创建线程时设置顾客姓名
            String customerName = String.valueOf(customer);
            // 开始发生购买行为
            Thread purchaseBehavior = new Thread(thread,customerName);
            // 发生购买行为
            purchaseBehavior.start();
        }
    }
}

如上代码运行后，注意每次运行的结果都是不一样的，着重看一下结尾的输出。 运行后的输出为：

剩余库存量：100件。顾客A购买4件商品。剩余库存量：96件。
剩余库存量：96件。顾客D购买2件商品。剩余库存量：94件。
剩余库存量：94件。顾客E购买10件商品。剩余库存量：84件。
剩余库存量：84件。顾客R购买10件商品。剩余库存量：74件。
剩余库存量：74件。顾客B购买5件商品。剩余库存量：69件。
剩余库存量：69件。顾客F购买7件商品。剩余库存量：62件。
剩余库存量：62件。顾客I购买6件商品。剩余库存量：56件。
剩余库存量：56件。顾客K购买5件商品。剩余库存量：51件。
剩余库存量：51件。顾客J购买4件商品。剩余库存量：47件。
剩余库存量：47件。顾客L购买6件商品。剩余库存量：41件。
剩余库存量：41件。顾客M购买2件商品。剩余库存量：39件。
剩余库存量：39件。顾客N购买2件商品。剩余库存量：37件。
剩余库存量：37件。顾客O购买10件商品。剩余库存量：27件。
剩余库存量：27件。顾客P购买6件商品。剩余库存量：21件。
剩余库存量：21件。顾客S购买5件商品。剩余库存量：16件。
剩余库存量：16件。顾客U购买4件商品。剩余库存量：12件。
剩余库存量：12件。顾客T购买7件商品。剩余库存量：5件。
剩余库存量：5件，顾客需求量：8件。库存不足，请尽快补充库存！
剩余库存量：5件，顾客需求量：8件。库存不足，请尽快补充库存！
剩余库存量：5件。顾客Y购买5件商品。剩余库存量：0件。
剩余库存量：0件，顾客需求量：1件。库存不足，请尽快补充库存！
剩余库存量：0件，顾客需求量：9件。库存不足，请尽快补充库存！
剩余库存量：0件，顾客需求量：7件。库存不足，请尽快补充库存！
剩余库存量：0件，顾客需求量：9件。库存不足，请尽快补充库存！
剩余库存量：0件，顾客需求量：8件。库存不足，请尽快补充库存！
剩余库存量：0件，顾客需求量：4件。库存不足，请尽快补充库存！