21、多线程(线程与进程\线程的实现方式\线程的声明周期\线程同步与死锁\生产者消费者问题)

一、线程基础内容

1、程序、进程与线程

1.1、程序:Program,是一个指令的集合

1.2、进程:Process,(正在执行中的程序)是一个静态的概念

• 进程是程序的一次静态态执行过程, 占用特定的地址空间（资源）.
• 每个进程都是独立的，由3部分组成cpu,data,code（执行逻辑）
• 缺点：内存的浪费，cpu的负担

1.3、线程:是进程中一个“单一的连续控制流程” (a singlesThread,equential flow of control)/执行路径

• 线程又被称为轻量级进程(lightweight process)。
• Threads run at the same time, independently of one another
• 一个进程可拥有多个并行的(concurrent)线程
• 一个进程中的线程共享相同的内存单元/内存地址空间--》可以访问相同的变量和对象，而且它们从同一堆中分配对象--》通信、数据交换、同步操作
• 由于线程间的通信是在同一地址空间上进行的，所以不需要额外的通信
• 机制，这就使得通信更简便而且信息传递的速度也更快。

一个进程中至少有一个线程

• Java虚拟机启动的时候会有一个进程java.exe,该进程中

           至少有一个线程，在负责java程序的执行。而且这个线程

           运行的代码存在亍main方法中,该线程称之为主线程。

           一个进程中的线程共享代码和数据空间

•  线程结束，进程未必结束，但进程结束，线程一定结束
• 进程中包含线程，线程是进程的一部分

2、线程的创建和启动

• 在Java中负责线程的这个功能的是Java.lang.Thread 这个类
• 可以通过创建 Thread 的实例来创建新的线程。
• 每个线程都是通过某个特定Thread对象所对应的方法run( )来完成其操作的，方法run( )称为线程体。
• 通过调用Thead类的start()方法来启动一个线程。

创建线程的方式一》继承Thread类 

 一个多线程的程序

public class ThreadDemo01 extends Thread {

    @Override
    public void run() {
//        super.run();
        for (int i=0; i<10; i++){
            System.out.println(Thread.currentThread().getName()+"--------------"+i);
        }
    }

    public static void main(String[] args) {
        ThreadDemo01 threadDemo01 = new ThreadDemo01();
        threadDemo01.start();
        for (int i=0; i<5; i++){
            System.out.println(Thread.currentThread().getName()+"==========="+i);
        }

    }
}

打印结果为：

/*
main===========0
Thread-0--------------0
main===========1
Thread-0--------------1
main===========2
Thread-0--------------2
main===========3
Thread-0--------------3
main===========4
Thread-0--------------4
Thread-0--------------5
Thread-0--------------6
Thread-0--------------7
Thread-0--------------8
Thread-0--------------9
*/

/**
 * 实现多线程的时候：
 *      1、需要继承Thread类
 *      2、必须要重写run方法，指的是核心执行的逻辑
 *      3、线程在启动的时候，不要直接调用run方法，而是要通过start()来进行调用
 *      4、每次运行相同的代码，出来的结果可能不一样，原因在于多线程谁先抢占资源无法进行人为控制
*/

另一种方式, 用的更多

创建线程的方式二-->实现Runnable接口

public class RunnableDemo implements Runnable {
    @Override
    public void run() {
        for(int i = 0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+"--------------"+i);
        }
    }

    public static void main(String[] args) {
        RunnableDemo runnableDemo = new RunnableDemo();
        Thread thread = new Thread(runnableDemo);
        thread.start();
        for(int i =0;i<5;i++){
            System.out.println(Thread.currentThread().getName()+"==========="+i);
        }
    }
}

打印结果为：

/*
Thread-0--------------0
main===========0
Thread-0--------------1
main===========1
Thread-0--------------2
main===========2
Thread-0--------------3
Thread-0--------------4
Thread-0--------------5
Thread-0--------------6
Thread-0--------------7
Thread-0--------------8
Thread-0--------------9
main===========3
main===========4

Process finished with exit code 0

*/

/**
 *  第二种实现方式：使用了代理设计模式
 *      1、实现Runnable接口
 *      2、重写run方法
 *      3、创建Thread对象，将刚刚创建好的runnable的子类实现作为thread的构造参数
 *      4、通过thread.start()进行启动
 */

/** 
 *    推荐使用第二种方式，
 *      1、java是单继承，将继承关系留给最需要的类
 *      2、使用runnable接口之后不需要给共享变量添加static关键字，每次创建一个对象，作为共享对象即可
 */

思考买票过程: 同一张票可能会被n多个人抢票

版本1:Thread创建

public class TicketThread extends Thread{

    private int ticket = 5; // 一共5张票

    @Override
    public void run() {
          System.out.println(Thread.currentThread().getName() + "正在出售第" + (ticket--) + "张票");
    }

    public static void main(String[] args) {
        TicketThread t1 = new TicketThread();
        TicketThread t2 = new TicketThread();
        TicketThread t3 = new TicketThread();
        TicketThread t4 = new TicketThread();

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

public class TicketThread extends Thread{

    private int ticket = 5; // 一共5张票

    @Override
    public void run() {
        for(int i = 0;i<100;i++){
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + "正在出售第" + (ticket--) + "张票");
            }
        }
    }

    public static void main(String[] args) {
        TicketThread t1 = new TicketThread();
        TicketThread t2 = new TicketThread();
        TicketThread t3 = new TicketThread();
        TicketThread t4 = new TicketThread();

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

运行结果为:

/*
Thread-0正在出售第5张票
Thread-3正在出售第5张票
Thread-1正在出售第5张票
Thread-2正在出售第5张票
Thread-1正在出售第4张票
Thread-0正在出售第4张票
Thread-3正在出售第4张票
Thread-0正在出售第3张票
Thread-1正在出售第3张票
Thread-1正在出售第2张票
Thread-1正在出售第1张票
Thread-2正在出售第4张票
Thread-0正在出售第2张票
Thread-3正在出售第3张票
Thread-3正在出售第2张票
Thread-0正在出售第1张票
Thread-2正在出售第3张票
Thread-2正在出售第2张票
Thread-2正在出售第1张票
Thread-3正在出售第1张票

Process finished with exit code 0

*/

每个线程都是 5 4 3 2 1

每个对象实例化时都拥有ticket 这样一个属性值, 意味着每个堆空间都有一个5

开启线程后, 每个对象都是操作当前堆空间里的这个5, 所以每个线程都是5 4 3 2 1

 static, 静态变量归属于类 而不归属实例对象

public class TicketThread extends Thread{

    private static int ticket = 5; // 一共5张票

    @Override
    public void run() {
        for(int i = 0;i<100;i++){
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + "正在出售第" + (ticket--) + "张票");
            }
        }
    }

    public static void main(String[] args) {
        TicketThread t1 = new TicketThread();
        TicketThread t2 = new TicketThread();
        TicketThread t3 = new TicketThread();
        TicketThread t4 = new TicketThread();

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

打印结果为:

 4 3 2 1 5, 顺序不对, 有一个数据同步问题

版本2:使用runnable

public class TicketRunnable implements Runnable {

    private int ticket = 5;

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + "正在出售第" + (ticket--) + "张票");
            }
        }
    }

    public static void main(String[] args) {
        TicketRunnable ticket = new TicketRunnable();
        Thread t1 = new Thread(ticket);
        Thread t2 = new Thread(ticket);
        Thread t3 = new Thread(ticket);
        Thread t4 = new Thread(ticket);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

打印结果为:

 这里就不用static了, 一个实例,5个线程都是用的这一个ticket

 

在用线程同步实现之前先说下代理的设计模式

定义一个接口

public interface KindWomen {

    /*
    * 抛媚眼
    * */
    public void makeEyesWithMen();

    public void playWithMen();

}

王婆是代理人

/*
*
* 代理人
* */
public class WangPo implements KindWomen {

    private KindWomen kindWomen;

    public WangPo(){
        this.kindWomen = new PanJinLian();
    }

    public WangPo(KindWomen kindWomen){
        this.kindWomen = kindWomen;
    }

    @Override
    public void makeEyesWithMen() {
        this.kindWomen.makeEyesWithMen();
    }

    @Override
    public void playWithMen() {
        this.kindWomen.playWithMen();
    }
}

潘金莲真正做事的人

public class PanJinLian implements KindWomen{
    @Override
    public void makeEyesWithMen() {
        System.out.println("潘金莲在抛媚眼");
    }

    @Override
    public void playWithMen() {
        System.out.println("潘金莲。。。。。");
    }
}

贾氏也是真正做事的人

public class JiaShi implements KindWomen{
    @Override
    public void makeEyesWithMen() {
        System.out.println("贾氏抛媚眼");
    }

    @Override
    public void playWithMen() {
        System.out.println("贾事。。。。。");
    }
}

西门庆是客户

public class XiMenQing {
    public static void main(String[] args) {

//        WangPo wangPo = new WangPo();
//        wangPo.playWithMen();
//        wangPo.makeEyesWithMen();

        JiaShi jiaShi = new JiaShi();
        WangPo wangPo = new WangPo(jiaShi);
        wangPo.makeEyesWithMen();
        wangPo.playWithMen();

    }
}

王婆是代理人, 真正做事的是贾氏

 3、线程状态

▪ 新生状态

– 用new关键字建立一个线程后，该线程对象就处于新生状态。

– 处于新生状态的线程有自己的内存空间，通过调用start()方法进入就绪状态。

▪ 就绪状态

– 处于就绪状态线程具备了运行条件，但还没分配到CPU，处于线程就绪队列，等待系统为其分

配CPU。

– 当系统选定一个等待执行的线程后，它就会从就绪状态进入执行状态，该动作称为“CPU调

度”。

▪ 运行状态

– 在运行状态的线程执行自己的run方法中代码,直到等待某资源而阻塞或完成任何而死亡。

– 如果在给定的时间片内没有执行结束，就会被系统给换下来回到等待执行状态。

▪ 阻塞状态

– 处于运行状态的线程在某些情况下，如执行了sleep(睡眠)方法，或等待I/O设备等资源，将让

出CPU并暂时停止自己运行，进入阻塞状态。

– 在阻塞状态的线程不能进入就绪队列。只有当引起阻塞的原因消除时，如睡眠时间已到，或等

待的I/O设备空闲下来，线程便转入就绪状态，重新到就绪队列中排队等待，被系统选中后从

原来停止的位置开始继续执行。

▪ 死亡状态

– 死亡状态是线程生命周期中的最后一个阶段。线程死亡的原因有三个，一个是正常运行

的线程完成了它的全部工作；另一个是线程被强制性地终止，如通过stop方法来终止一个

线程【不推荐使用】；三是线程抛出未捕获的异常。

 

api方法：

 

public class ThreadApiDemo  implements Runnable{
    public static void main(String[] args) {
        //获取当前线程对象
        Thread thread = Thread.currentThread();
        //获取当前线程的名称
        System.out.println(thread.getName());
        //获取线程的id
        System.out.println(thread.getId());
        //获取线程的优先级,在一般系统中范围是0-10的值，如果没有经过设置的话，就是默认值5，有些系统是0-100
        System.out.println(thread.getPriority());
        //设置线程池的优先级
        /*
        * 优先级越高一定越先执行吗？
        *       不一定，只是优先执行的概率比较大而已
        * */
        thread.setPriority(6);
        System.out.println(thread.getPriority());

        ThreadApiDemo threadApiDemo = new ThreadApiDemo();
        Thread t1 = new Thread(threadApiDemo);
        System.out.println(t1.isAlive()); // 判断是否存活
        t1.start();
        System.out.println(t1.isAlive());
        System.out.println(t1.getPriority());
//        for(int i = 0;i<5;i++){
//            System.out.println(Thread.currentThread().getName()+"-----"+i);
//        }
        System.out.println(t1.isAlive());
    }

    @Override
    public void run() {
//        for(int i = 0;i<5;i++){
//            System.out.println(Thread.currentThread().getName()+"-----"+i);
//        }
    }
}

 join方法:

public class MyRun implements Runnable {
    @Override
    public void run() {
        for(int i = 0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+"------"+i);
        }
    }
}

public class JoinTest {
    public static void main(String[] args) {
        MyRun run = new MyRun();
        Thread thread = new Thread(run);
        thread.start();

        for(int i = 0;i<5;i++){
            System.out.println(Thread.currentThread().getName()+"-----------------"+i);
            if(i==3){
                try {
                    thread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

/*
main-----------------0
main-----------------1
main-----------------2
main-----------------3
Thread-0------0
Thread-0------1
Thread-0------2
Thread-0------3
Thread-0------4
Thread-0------5
Thread-0------6
Thread-0------7
Thread-0------8
Thread-0------9
main-----------------4

Process finished with exit code 0
*/

main i==3 后, 执行join(), 从运行态到阻塞态

MyRun线程开始执行,执行完成后轮到 main继续执行

 sleep()方法

public class SleepTest {
    public static void main(String[] args) {
        MyRun run = new MyRun();
        Thread thread = new Thread(run);
        thread.start();

        for(int i = 0;i<5;i++){
            System.out.println(Thread.currentThread().getName()+"=============="+i);
            if(i==2){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

/*
main==============0
main==============1
main==============2
Thread-0------0
Thread-0------1
Thread-0------2
Thread-0------3
Thread-0------4
Thread-0------5
Thread-0------6
Thread-0------7
Thread-0------8
Thread-0------9
main==============3
main==============4

Process finished with exit code 0
*/

main 到2 时 , 1sThread都执行完了,继续执行main 3 4

yield()方法:

public class YieldTest {
    public static void main(String[] args) {
        MyRun run = new MyRun();
        Thread thread = new Thread(run);
        thread.start();

        for(int i = 0;i<5;i++){
            if(i==2){
                Thread.yield();
//                thread.stop();
                System.out.println(Thread.currentThread().getName()+"=============="+i+"礼让一次");
            }else{
                System.out.println(Thread.currentThread().getName()+"=============="+i);

            }
        }
    }
}

打印结果为:

/*
main==============0
Thread-0------0
main==============1
Thread-0------1
Thread-0------2
Thread-0------3
Thread-0------4
Thread-0------5
main==============2礼让一次
main==============3
Thread-0------6
main==============4
Thread-0------7
Thread-0------8
Thread-0------9

Process finished with exit code 0
*/

礼让一次后,又出现了main 3 又去竞争资源并且抢占到了资源

stop()方法: 过时了,不推荐使用

public class YieldTest {
    public static void main(String[] args) {
        MyRun run = new MyRun();
        Thread thread = new Thread(run);
        thread.start();

        for(int i = 0;i<5;i++){
            if(i==2){
//                Thread.yield();
                thread.stop();
                System.out.println(Thread.currentThread().getName()+"=============="+i+"礼让一次");
            }else{
                System.out.println(Thread.currentThread().getName()+"=============="+i);

            }
        }
    }
}

打印结果为:

/*
main==============0
main==============1
Thread-0------0
Thread-0------1main==============2礼让一次
main==============3
main==============4

Process finished with exit code 0
*/

2 以后强制结束了

父类Object 有几个非常重要的方法

notify() 唤醒

wait() 等待

线程会有些误解, 因为先说的Object类, 前面说notify和wait会在多线程中说

所有的类都有等待和唤醒的方法,也就是说时对象有等待和唤醒的方法,而不是说线程有等待和唤醒方法

在多线程的时候，可以实现唤醒和等待的过程，但是唤醒和等待操作的对应不是thread类, 而是我们设置的共享对象或者共享变量

public class Test1 implements Runnable{


    @Override
    public void run() {
        for(int i = 0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+"====="+i);
            try {
                Thread.sleep(1001);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Test1 test1 = new Test1();
        Thread thread = new Thread(test1);
        thread.start();
        for(int i=10;i>0;i--){
            System.out.println(Thread.currentThread().getName()+"----"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

打印结果为:

/*
main----10
Thread-0=====0
main----9
Thread-0=====1
main----8
Thread-0=====2
main----7
Thread-0=====3
main----6
Thread-0=====4
main----5
Thread-0=====5
main----4
Thread-0=====6
main----3
Thread-0=====7
main----2
Thread-0=====8
main----1
Thread-0=====9

Process finished with exit code 0
*/

二、线程同步

/*
 *      多线程并发访问的时候回出现数据安全问题：
 *          解决方式：
 *              1、同步代码块
 *                  synchronized(共享资源、共享对象，需要是object的子类){具体执行的代码块}
 *              2、同步方法
 *                  将核心的代码逻辑定义成一个方法，使用synchronized关键字进行修饰，此时不需要指定共享对象
 *
 */
*/

▪ 同步的前提:

▪ (1)必须有两个或两个以上的线程

▪ (2)必须是多个线程使用同一资源

▪ (3)必须保证同步中只能有一个线程在运行

多线程同时访问同一份资源, 这样才会出现线程安全问题

加synchronized相当于加了一把锁, 只能有一个线程对它访问

 

买票问题

1、同步代码块

public class TicketRunnable2 implements Runnable {

    private int ticket = 5;

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (this){
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + (ticket--) + "张票");
                }
            }
        }
    }

    public static void main(String[] args) {
        TicketRunnable2 ticket = new TicketRunnable2();
        Thread t1 = new Thread(ticket,"A");
        Thread t2 = new Thread(ticket,"B");
        Thread t3 = new Thread(ticket,"C");
        Thread t4 = new Thread(ticket,"D");

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

 打印结果为：

/*
D正在出售第5张票
C正在出售第4张票
A正在出售第3张票
B正在出售第2张票
A正在出售第1张票

Process finished with exit code 0
*/

2、同步方法

public class TicketRunnable3 implements Runnable {

    private int ticket = 5;

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.sale();
        }
    }

    /*
     * 使用同步方法解决多线程数据安全的问题
     * */
    public synchronized void sale() {

        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + "正在出售第" + (ticket--) + "张票");
        }
    }

    public static void main(String[] args) {
        TicketRunnable3 ticket = new TicketRunnable3();
        Thread t1 = new Thread(ticket, "A");
        Thread t2 = new Thread(ticket, "B");
        Thread t3 = new Thread(ticket, "C");
        Thread t4 = new Thread(ticket, "D");

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

打印结果为:

/*
B正在出售第5张票
C正在出售第4张票
D正在出售第3张票
A正在出售第2张票
D正在出售第1张票

Process finished with exit code 0
*/

▪ 同步监视器

　　– synchronized(obj){}中的obj称为同步监视器

　　– 同步代码块中同步监视器可以是任何对象，但是推荐使用共享资源作为同步监视器

　　– 同步方法中无需指定同步监视器，因为同步方法的监视器是this，也就是该对象本身

▪ 同步监视器的执行过程

　　– 第一个线程访问，锁定同步监视器，执行其中代码

　　– 第二个线程访问，发现同步监视器被锁定，无法访问

　　– 第一个线程访问完毕，解锁同步监视器

　　– 第二个线程访问，发现同步监视器未锁，锁定并访问

三、死锁

▪ 同步可以保证资源共享操作的正确性，但是过多同步也会产生死锁

▪ 死锁一般情况下表示互相等待，是程序运行时出现的一种问题

四、线程的生产者与消费者

▪ 生产者不断生产，消费者不断取走生产者生产的产品 

▪ 生产者生产产品放到一个区域中，之后消费者从此区域里取出产品，区域值的是共享资源

/*
 *
 * 生产产品，将产品放置到共享空间中
 *
 * */
public class Producer implements Runnable {

}

/*
*
* 从共享空间中取走产品
* */
public class Consumer implements Runnable {

}

public class Goods {

    private String brand; // 品牌
    private String name; // 名称

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

1、版本一

保证生产者先生产产品

public class Producer implements Runnable {

    private Goods goods;

    public Producer(Goods goods) {
        this.goods = goods;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            if (i % 2 == 0) {
                goods.setBrand("娃哈哈");
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                goods.setName("矿泉水");
            } else {
                goods.setBrand("旺仔");
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                goods.setName("小馒头");

            }
            System.out.println("生产者生产了" + this.goods.getBrand() + "--" + this.goods.getName());
        }
    }
}

/*
*
* 从共享空间中取走产品
* */
public class Consumer implements Runnable {

    private Goods goods;

    public Consumer(Goods goods) {
        this.goods = goods;
    }

    @Override
    public void run() {
        for(int i = 0;i<10;i++){
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("消费者取走了"+this.goods.getBrand()+"----"+this.goods.getName());
        }
    }
}

/*
* 多线程访问的时候出现了数据安全的问题
*   1、生产者没有生产商品，消费者就可以获取
*   2、商品的品牌和名称对应不上
*
* */
public class Test {
    public static void main(String[] args) {

        Goods goods = new Goods();

        Producer producer = new Producer(goods);
        Consumer consumer = new Consumer(goods);

        Thread t1 = new Thread(producer);
        Thread t2 = new Thread(consumer);
        t1.start();
        t2.start();


    }
}

打印结果为:

 

 2、版本二

同步方法解决， 不需要指定共享对象

public class Goods {

    private String brand;
    private String name;

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    //消费者获取商品
    public synchronized void get(){
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("消费者取走了"+this.getBrand()+"----"+this.getName());
    }
    //生产者生产商品
    public synchronized void set(String brand,String name){
       this.setBrand(brand);
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.setName(name);
        System.out.println("生产者生产了" + this.getBrand() + "--" + this.getName());
    }
}

/*
 *
 * 生产产品，将产房放置到共享空间中
 *
 * */
public class Producer implements Runnable {

    private Goods goods;

    public Producer(Goods goods) {
        this.goods = goods;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            if (i % 2 == 0) {
                goods.set("娃哈哈","矿泉水");
            } else {
                goods.set("旺仔","小馒头");
            }
        }
    }
}

/*
*
* 从共享空间中取走产品
* */
public class Consumer implements Runnable {

    private Goods goods;

    public Consumer(Goods goods) {
        this.goods = goods;
    }

    @Override
    public void run() {
        for(int i = 0;i<10;i++){
            goods.get();
        }
    }
}

public class Test {
    public static void main(String[] args) {

        Goods goods = new Goods();

        Producer producer = new Producer(goods);
        Consumer consumer = new Consumer(goods);

        Thread t1 = new Thread(producer);
        Thread t2 = new Thread(consumer);
        t1.start();
        t2.start();
    }
}

打印结果为：

 还是存在问题，下面都是消费者，但是品牌和名称已经对应起来了

刚刚生产过程不是一个原子操作，把生产过程已经放到了set了

 这里是一个原子操作了，加了synchronized，这里是不会发生中断的，品牌和名称要么全部成功，要么全部失败

所以品牌和名称会全部对应起来，已经解决了一个问题

3、版本三

我们要改变的只有goods方法

先判断只有生产者先生产消费者才能消费

public class Goods {

    private String brand;
    private String name;
    //默认是不存在商品的，如果值等于true的话，代表有商品
    private boolean flag = false;

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    //消费者获取商品
    public synchronized void get(){
        /*
        * 如果flag等于false的话，意味着生产者没有生产商品，此时消费者无法消费，需要让消费者线程进入到阻塞状态，等待生产者生产，当
        * 有商品之后，再开始消费
        * */
        if (!flag){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("消费者取走了"+this.getBrand()+"----"+this.getName());
        flag = false;
        //唤醒生产者去进行生产
        notify();
    }
    //生产者生产商品
    public synchronized void set(String brand,String name){
        //当生产者抢占到cpu资源之后会判断当前对象是否有值，如果有的话，以为着消费者还没有消费，需要提醒消费者消费，同时
        //当前线程进入阻塞状态，等待消费者取走商品之后，再次生产，如果没有的话，不需要等待，不需要进入阻塞状态，直接生产即可
        if(flag){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
       this.setBrand(brand);
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.setName(name);
        System.out.println("生产者生产了" + this.getBrand() + "--" + this.getName());
        //如果代码执行到此处，意味着已经生产完成，需要将flag设置为true
        flag = true;
        //唤醒消费者去进行消费
        notify();
    }
}

打印结果为：

 4、版本4

上面基本是完成了生产者消费者

我们代码里就设置了一个Goods对象，对象只有 1 个

在现实中，共享空间不可能只有 1 个， 肯定不合适

要放一个集合在这

集合该如何处理？？？ 

集合判断一堆的等待一堆的唤醒，非常麻烦

这样就有了JUC

java util 下有一个concurrent

 这里面就帮我们解决并发问题

队列的方式

import java.util.concurrent.BlockingQueue;

public class ProducerQueue implements Runnable {

    private BlockingQueue<Goods> blockingQueue;

    public ProducerQueue(BlockingQueue blockingQueue) {
        this.blockingQueue = blockingQueue;
    }

    @Override
    public void run() {
        for(int i = 0;i<10;i++){
            Goods goods = null;
            if(i%2==0){
                goods = new Goods("娃哈哈","矿泉水");
            }else{
                goods = new Goods("旺仔","小馒头");
            }
            System.out.println("生产者开始生产商品："+goods.getBrand()+"--"+goods.getName());
            try {
                blockingQueue.put(goods);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

import java.util.concurrent.BlockingQueue;

public class ConsumerQueue implements Runnable {

    private BlockingQueue<Goods> blockingQueue;

    public ConsumerQueue(BlockingQueue blockingQueue) {
        this.blockingQueue = blockingQueue;
    }

    @Override
    public void run() {
        for(int i = 0;i<10;i++){
            try {
                Goods goods = blockingQueue.take();
                System.out.println("消费者消费的商品是："+goods.getBrand()+"--"+goods.getName());
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Goods {

    private String brand;
    private String name;

    public Goods(String brand, String name) {
        this.brand = brand;
        this.name = name;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

public class Test {
    public static void main(String[] args) {
        BlockingQueue<Goods> queue = new ArrayBlockingQueue<Goods>(5);
        ProducerQueue producerQueue = new ProducerQueue(queue);
        ConsumerQueue consumerQueue = new ConsumerQueue(queue);
        new Thread(producerQueue).start();
        new Thread(consumerQueue).start();


    }
}

打印结果为：

高级GUC

跳转路径