关于多线程的学习（下）

关于多线程的学习（下）

提到多线程，那必然提到经典题目——生产者消费者模型，使用多线程的方式模拟一个简单的生产者消费者模型，在仅考虑生产和消费轮流执行的情况下，即每次生产后必定进行消费，二者交替执行，且每次购买数量无法超过商品的存储，商品的总数不得超过一千。

首先需要定义一个对象表示商品：

public class Commodity {
//用于判断是生产还是消费
    public boolean flag=true;
    
    public int getNum() {
        return num;
    }
    public void setNum(int num) {
        this.num = num;
    }
    //总容量
    private static int num=0;
  
}

再定义一个生产者：

public class creatDemo implements Runnable {
   Commodity commodity;
    public creatDemo(Commodity commodity) {
        this.commodity = commodity;
    }
    public void run() {
        while (true) {
            synchronized (commodity) {
            //如果flag是false，让当前线程进入等待
            if (!commodity.flag) {
                try {
                    commodity.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //如果是true,进行生产
                if (commodity.flag) {
                //保证生产后总数不超过1000
                   int count = (int) Math.floor(Math.random() * (1000 - commodity.getNum()) + 1);
                    commodity.setNum(count + commodity.getNum());
                    System.out.println("本次生产" + count + ",总共还有" + commodity.getNum());
                    //将flag变为false
                    commodity.flag=false;
                    //唤醒线程池中沉睡的线程，开启下一次资源抢夺，但实际下
                   // 次要执行的操作早就确定了，这就是黑幕
                    commodity.notify();
                }
            }

        }
    }
}

我们再创建一个消费者：

public class ShopDemo implements Runnable {
    Commodity commodity;

    public ShopDemo(Commodity commodity) {
        this.commodity = commodity;
    }

    public void run() {
        while (true) {
            synchronized (commodity) {
            //如果是true，进入等待
                if (commodity.flag){
                    try {
                        commodity.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //如果是false，进行消费操作
            if (!commodity.flag) {
                  int count = (int) Math.floor(Math.random() * (commodity.getNum()) + 1);
                    commodity.setNum(commodity.getNum() - count);
                    System.out.println("本次购买" + count+"剩余"+commodity.getNum());
                    commodity.flag=true;
                    commodity.notify();
                }
            }

        }
    }
}

最后创建线程

public class test {
    public static void main(String[] args) {
        Commodity c=new Commodity();
        //使用匿名对象来直接构造
      new Thread(new creatDemo(c)).start();
      new Thread(new ShopDemo(c)).start();
    }
}

这样我们就实现了一个简单的消费者生产者模式，再此基础上我们可以不断添加其他的条件，例如只有商品数量为0时才会再去生产，或者生产和消费同时进行等其他操作。

总结：

• 线程的等待和唤醒机制可以人为控制线程之间的争夺资源（俗称暗箱操作），我们可以使用wait()将该线程进入等待状态，此时如果不进行notify()是无法继续执行该线程的。
• notify会随机唤醒线程池中的一条线程，而不是指定唤醒某条线程。

补充：

sleep和wait
1.sleep需要指定休眠时间，如果线程没有锁，那么会释放执行权。如果线程有锁，那么不释放执行权。这个方法是设计在Thread类上，是一个静态方法。可以使用Thread.sleep(0)让线程重新争夺资源。
2.wait可以指定也可以不指定时间，如果不指定时间需要进行唤醒。释放执行权也释放锁。这个方法是设计在Object上，是一个普通方法。如果指定了时间，也仍需被其他线程唤醒。

守护线程
守护线程用于守护被守护线程。如果被守护的线程结束，那么守护线程随之结束。
如果一个线程不是守护线程，那么就是被守护线程。如果所有的被守护线程结束，那么守护线程也会随之结束。最常见的守护线程就是GC。

线程的状态
创建、就绪、执行、阻塞、消亡

HashTable和ConcurrentHashMap的区别(仅线程安全)
HashTable是同步线程安全的，原因是它在底层为整个表加上了锁，一个大锁将整个表锁住，所以是同步的，但是效率极低。
HashMap虽然效率高，但是线程过于不安全，所以我们使用ConcurrentHashMap，它也是给线程加锁，但是它不是加一个大锁，JDK1.7是由Segment数组实现的，一个Segment锁住几个HashEntry元素；JDK1.8是由synchronized锁住transient volatile Node<K,V>[] table 数组的一个元素(即头结点，锁粒度比JDK1.7低)，还通过CAS(Unsafe对象)操作数据更新、插入等。（大致意思是进行操作时是对每个桶进行加锁，这样其他线程在进行非本链表的操作时不会受影响，JDK1.7之前是直接对segment加锁，1.8之后放弃了segment，对节点头加锁，这样消耗的资源会少，从而提高效率）