多线程(day02)

线程的生命周期

1. 创建线程状态（新建）。
2. 调用start方法后，变成就绪状态（有执行资格，没有执行权，此时会不停的抢占cpu）。
3. 当就绪状态的线程抢占到spu的执行权后，会变成运行状态（有执行资格，也有执行权），当cpu的执行权被其他线程抢占后，会从运行状态重新变成就绪状态。
4. 当线程运行完毕之后，就会死亡，变成垃圾被回收。
5. 当线程在运行状态中，调用sleep方法或者被其他方式阻塞了，此时线程进入阻塞等待状态，即没有执行资格也没有执行权，当sleep的时间到或者阻塞结束，线程会重新进入就绪状态，对cpu进行抢夺。

图示如下：

线程安全的问题

需求：某个电影院目前正在上映国产大片，共100张票，而它有三个窗口卖票，请设计一个程序模拟卖票

卖票引发的安全问题

1. 可能出现多个窗口重复卖同一张票
2. 可能出现超卖现象

原因：线程在执行过程中，具有随机性的，cpu的执行权有可能随时被其他线程抢走

synchronized

解决办法

基于上述问题，我们可以通过同步代码块的方式，将操作共享数据的代码块锁起来，这样在被锁住的时间内，其余线程就无法对共享的数据进行修改。
在Java中，我们可以通过synchronized关键字，对共享代码进行加锁，格式如下图:

synchronized锁的特点：

1. 锁默认打开，有一个线程进去了，锁就默认关闭
2. 里面的代码全部执行完毕，线程出来，锁自动打开

基于以上的解决办法，卖票问题的程序如下所示：

 public static void main(String[] args) {
        //创建线程对象，模拟三个窗口卖票
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();
        //起名字
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        //开始卖票
        t1.start();
        t2.start();
        t3.start();
    }

/*创建线程模拟卖票*/
public class MyThread extends Thread {
    //加上static关键字表示这个类所有的对象，都共享ticket数据
    //如果是通过Runnable接口创建线程，那么就不需要static关键字，因为此类对象只会被创建一次
    static int ticket = 0;

    //锁对象可以是任意的Object对象，但是锁对象都是唯一的
    static Object obj = new Object();
    @Override
    public void run(){
        while (true) {
            //同步代码块，使同步代码块内的对象是轮流执行的
            synchronized (obj){
                if(ticket<100){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    ticket++;
                    System.out.println(getName()+"正在卖第"+ticket+"张票");

                }else{
                    break;
                }
            }
        }
    }
}

synchronized同步代码块小细节

1. synchronized要写在循环内
2. synchronized内的锁对象一定要是唯一的，如果不是唯一锁，那么锁的意义就不存在了

同步方法

就是把synchronized关键字加到方法上
格式如下：

特点：

1. 同步方法是锁住方法里面所有的代码
2. 锁对象不能自己指定，如果当前方法为非静态方法，那么锁对象为当前方法的调用者，如果是静态方法，那么锁对象是当前类的字节码文件对象

技巧
如果不确定那部分代码写到同步方法内，可以先编写同步代码块，再将同步代码块中的代码抽取出来写到同步方法之中

Lock

Lock是JDK5之后提供的新的锁对象，Lock实现提供了比使用synchronized方法和语句可以获得更广泛的锁定操作

Lock中提供了获得锁和释放锁的方法，可以更清晰的表达如何加锁和释放锁:

void lock();//获得锁
void unlock();//释放锁

注意：
Lock是接口不能直接实例化，需要采用它的实现类ReentrantLock来实例化ReentrantLock的构造方法ReentrantLock()来创建一个ReentrantLock的实例

使用Lock解决上述卖票问题的代码如下:

/*创建线程模拟卖票*/
public class MyThread extends Thread {
    //加上static关键字表示这个类所有的对象，都共享ticket数据
    static int ticket = 0;
    static Lock lock = new ReentrantLock();
    @Override
    public void run(){
        while (true) {
            //同步代码块，使同步代码块内的对象是轮流执行的
           lock.lock();
           try{
               if(ticket<100){
                   Thread.sleep(10);
                   ticket++;
                   System.out.println(getName()+"正在卖第"+ticket+"张票");
               }else{
                   break;
               }
           }catch (InterruptedException e){
               e.printStackTrace();
           }finally {
               lock.unlock();
           }
        }
    }
}

生产者和消费者(等待唤醒机制)

生产者和消费者是一个十分经典的多线程协作模式

唤醒的方法为notify()，等待的方法为wait()，唤醒所有线程为notifyAll()

生产者负责生成资源，消费者负责消耗资源，当生产者获取到cpu的执行权时，会对资源进行判断，如果没有资源，则进行生产，如果有资源，则进行等待wait，如果在等待的过程中，消费者获取到cpu的执行权，则会消耗资源，资源消耗完毕，则会通过notify()方法唤醒生产者继续生成资源

代码实现如下:
生成者：

public class Cook extends Thread{
    /*生产者：厨师*/

    @Override
    public void run() {
         /*
        多线程实现的四步套路：
         * 1. 循环
         * 2. 同步代码块
         * 3. 判断共享数据是否到了末尾(到了末尾)
         * 4. 判断共享数据是否到了末尾(没到末尾。执行核心逻辑)
         * */
        while (true) {
            synchronized (Desk.lock){
                //判断共享数据是否到了末尾
                if(Desk.count == 0){
                    break;
                }else{
                    //判断桌子上是否有食物
                    if(Desk.foodFlag == 1){
                        //如果有，就等待
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }else{
                        //如果没有，就制作
                        System.out.println("厨师做了一碗面条");
                        //修改桌子上的食物状态
                        Desk.foodFlag = 1;
                        //叫醒等待的消费者
                        Desk.lock.notifyAll();
                    }
                }
            }
        }
    }
}

消费者：

public class Foodie extends Thread{


    @Override
    public void run() {
        /*消费者：吃货
        多线程实现的四步套路：
         * 1. 循环
         * 2. 同步代码块
         * 3. 判断共享数据是否到了末尾(到了末尾)
         * 4. 判断共享数据是否到了末尾(没到末尾。执行核心逻辑)
         * */
        while (true) {
            synchronized (Desk.lock){
                if(Desk.count == 0){
                    break;
                }else{
                    //先判断是否有资源
                    if(Desk.foodFlag==0){
                        //如果没有就等待
                        try {
                            Desk.lock.wait();//让当前线程和锁进行绑定，为了后续的线程唤醒
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }else{
                        //将资源数-1
                        Desk.count--;
                        //如果有，就开吃
                        System.out.println("吃货正在吃面条，还能吃"+Desk.count+"碗");
                        //吃完之后，唤醒生产者生产资源
                        Desk.lock.notifyAll();//使用锁调调用notifyAll，表示唤醒和这个锁绑定的所有线程
                        //修改桌子的状态
                        Desk.foodFlag = 0;
                    }

                }
            }
        }
    }
}

桌子：

public class Desk {
    /*
    * 作用：控制生产者和消费者的执行
    * */
    //是否有面条 0：没有面条 1：有面条
    public static int foodFlag = 0;

    //总个数,消费者可消耗的资源数
    public static int count = 10;

    //锁对象
    public static Object lock = new Object();
}