多线程操作与逻辑——售票系统

实现原理

使用多线程进行操作，无论是用多线程写售票系统还是其他什么，它们的原理无非都是线程操作资源类——七字真言
通过一个简单的多线程实现的售票系统的示例，来理解多线程的使用思路和逻辑。
根据以上原理，我们大致是需要创建三个类的：

线程类——mian类，用来创建并开启线程。
操作类——实现票数的售卖操作。
资源类——包含一个简单的成员属性。

资源类

建一个资源类Resource，只需要一个属性number，然后就是无参构造和有参构造以及给封装属性的get/set方法。

package comt.多线程;
public class Resource {
    private int number;
    public Resource(){};
    public Resource(int number) {
        this.number = number;
    }
    public void setNumber(int number){
        this.number = number;
    }
    public int getNumber(){
        return number;
    }
}

操作类

创建一个操作类，继承Runnable类，写上一sale()方法，实现对票的售卖操作。

package comt.多线程;

public class Operate implements Runnable {
    private Resource resource; ;
    public Operate(){};
    public Operate(Resource resource) {
        this.resource = resource;
    }
    public void sale() {
        System.out.println(Thread.currentThread().getName() + "正在卖第" + (100 - resource.getNumber()) + "张票，还剩" + resource.getNumber() + "张票");
        resource.setNumber(resource.getNumber() - 1);
    }
    @Override
    public void run() {
        while(resource.getNumber()>0){
            sale();
        }
    }
}

线程类——（mian方法类）

package comt.多线程;
public class Test {
    public static void main(String[] args) {
        Resource resource = new Resource(100);
        Operate operate = new Operate(resource);
        new Thread(()-> {
            while (resource.getNumber() > 0) {
                operate.sale();
        }
            },"窗口1").start();
        new Thread(()-> {
            while (resource.getNumber() > 0) {
                operate.sale();
            }
        },"窗口2").start();
        new Thread(()-> {
            while (resource.getNumber() > 0) {
                operate.sale();
            }
        },"窗口3").start();
    }
}

在main方法中，创建了一个Resource对象和一个Operate对象，并使用三个线程分别表示三个售票窗口。在线程中使用while循环不断调用Operate对象的sale()方法，直到票数为0。
创建线程对象时，没有使用普通线程的创建方法，我们使用的是Lambda表达式的方式创建线程并实现开启线程。

        Thread t = new Thread();
        t.setName("窗口4");
        t.start();
        Thread t = new Thread();
        t.setName("窗口5");
        t.start();
        Thread t = new Thread();
        t.setName("窗口6");
        t.start();

像这种的线程创建并开启方式，但线程开启的多了之后，代码就会显得冗余，使用Lambda表达式看起来也比较高级。不会让代码看起来繁琐。

运行结果

显而易见，我们创建的三个线程都参与了售票。结果也如我们想象那样运行。
但是仔细一看，运行结构又不完全一样。
窗口2卖到了第51张，到窗口1时还在卖第87张。出现这种情况是多线程在虚拟机运行机制导致的。
用下面例子来看：

public class test {
    public static void main(String[] args) {
        tickets t =new tickets(100);
        t.setName("分支线程");
        t.start();
        while(t.getNum()>0){
            t.sale();
        }
    }
}

tickets类的sale方法和run方法。

    public void sale(){
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        int cnt=this.num;
        cnt--;
        System.out.println(Thread.currentThread().getName()+"正在出售第"+this.num+"张票，剩余票数"+cnt);
        num--;
    }
    public void run(){
        while(this.num>0)sale();
    }

运行程序时start方法就会启动run方法，开始票数的售卖。
运行如下;

同时也反证了main类是一个线程。
首先得知道这个main类里一共是三个线程：main线程（主线程），线程t（我们创建的），以及垃圾回收线程（负责看护回收垃圾）。
我们运行这个main方法时，在JVM中首先是main方法压栈，然后就是我们的setName方法，在然后是start方法。
入栈图如下：

当start方法弹出后，就会运行run方法，然后main类里的sale()方法也会执行。
理论逻辑上应该是执行顺序是start开启run方法，执行完在main的sale方法。实际出来时不是。
之所以出现main和分支线程同时在卖的情况是因为，栈中start方法会在JVM中在开一个栈，来执行run方法。start弹出后就没了，main的栈里执行sale方法,同时start也开了一个栈在执行run方法。由于CPU的调度时间不同，所以两个线程的运行次数也不一样。两个线程对同一个票进行售卖，于是出现了对同一资源的争抢。CPU调度分支线程时，分支线程可能才获取到剩余票数，CPU又去调度main线程，调度main线程时间比分支线程长。于是就出现了main线程卖完第96张时，开始卖第94张时，而分支线程还在卖第96张。

解决方法

要解决上述问题，我们需要一把锁，把资源锁住。
依次只能一个线程执行。
好比很多人上厕所，厕所却只有一个，所以肯定会争抢。如果我们给厕所加一个锁，里面的人不出来，外面的进不去，这样保证了一次进厕所的只有一个。
于是引进了synchronized——同步锁
一旦有线程获取了资源，那就只有等这个线程执行完了，下一个线程才能去获取资源类。
我们用synchronized来修饰sale方法。

    public synchronized void sale() {
        int sun=resource.getNumber();
        if(sun>0){
            System.out.println(Thread.currentThread().getName() + "正在卖第" +sun + "张票，还剩" + --sun + "张票");
            resource.setNumber(sun);
        }
    }

运行之后，就符合我们逻辑了。并且数据也不会乱。