今日整理:
1.自己说说什么是进程,什么线程?
2.实现多线程有几种方式?分别是什么?
3.什么是线程同步?为什么我们需要线程同步?
4.Java中有哪些是线程安全的?举3个例子并说明
5.什么是Lock锁?
6.讲讲今天的生产者和消费者的案例?

1.进程是系统正在运行的一个程序（比如QQ），线程是在进程内部同时做的事情（QQ发信息，接收信息）
2.有两种方式，第一种是：创建一个继承Thread的子类，重写它的run方法，创建子类对象，用start开启线程
                       第二种是：创建一个实现Runnable接口的类，实现接口的run方法，创建实现类对象，通过此对象创建                                                                                                                               Thread类的 对象，调用start启动线程。
3.线程同步是多个线程同时访问同一资源。因为线程同步可以解决线程的安全问题。
4.Hashtable，Vector，statck
5.lock锁可以控制同步访问的，与synchronized相比，lock可以知道啥时候开始锁了和啥时候关闭了锁。
6.生产者消费者模式就是通过一个中间的容器来解决生产者和消费者的强耦合问题。只有生产者生产了东西消费者才能去使用这个东西。

今日整理:
1.自己说说什么是进程,什么线程?
进程：可指的是一个正在执行的程序，它是系统在资源分配和调用的独立单位，每个进程都有它自己的内存空间和系统资源
线程：一个进程中的某个顺序控制流，也可以说是某条执行路径叫做线程
2.实现多线程有几种方式?分别是什么?
两种，一是继承Thread类，二是实现Runable接口
3.什么是线程同步?为什么我们需要线程同步?
线程同步其实就是实现线程排队，因为当我们有多个线程共同抢一个资源时，会造成资源冲突问题，这时候就需要线程同步来保证代码的安全性
4.Java中有哪些是线程安全的?举3个例子并说明
StringBuffered 是安全的，慢   StringBuilder是不安全的，但快
Vector         是安全的，慢   ArrayList     是不安全的，但快
HashTable      是安全的，慢   HashMap       是不安全的，但快
5.什么是Lock锁?
是一个能看到获得锁和释放锁的一个新的锁对象
6.讲讲今天的生产者和消费者的案例?
该案例其实有两条线程
线程一：生产者线程，用于生产数据
线程二：消费者线程，用于消费数据
  为了可以解耦两者之间的关系，可以添加体格共享的数据区，也可以说是一个仓库，或者缓冲区，生产者生产数据放到其中，消费者去消费数据

  

1.自己说说什么是进程,什么线程?
*进程是正在运行的程序
*线程是进程中的单个顺序控制流，是一条执行路径

2.实现多线程有几种方式?分别是什么?
*有两种方法
*分别是1.继承Thread类        2.实现Runnable接口
3.什么是线程同步?为什么我们需要线程同步?
*锁多条语句操作共享数据，
*因为线程同步可以解决多线程的安全问题
4.Java中有哪些是线程安全的?举3个例子并说明
*Vector、HashTable、Properties是线程安全的
5.什么是Lock锁?
*虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，jdk5以后提供了一个新的锁对象lock
6.讲讲今天的生产者和消费者的案例?
*主要是包含了两类线程：
        *一类是生产者线程用于生产数据，生产者生产数据之后直接放在共享数据区中，并不关心消费者的行为
        *一类是消费者线程用于消费数据，消费者只需要从共享数据区中去获取数据，并不关心生产者的行为

今日整理:
1.自己说说什么是进程,什么线程?
进程：运行的一个程序，那么程序就是一个进程
线程：就是进程的一部分，是最小的系统单元
2.实现多线程有几种方式?分别是什么?
主要分为两种方式：
方式一：继承Thread,子类重写run方法。常用方法:start()开启线程，并且去执行run方法方法里面封装的代码
       缺点：
       1.无法共享同一个资源，没法处理同一个资源，因为一个线程绑定一个资源，那么不同的线程绑定的不同的资源
       2.只能单继承，继承了其他类就无法继承Thread，就不是线程类，无法进行后续扩展
方式二：实现runnable接口，创建类实现这个接口；重写run方法，创建Thread类对象，将这个实现类对象作为对象的参数传递，启动线程
       优点：
       1. 即使当前类继承了类和实现了接口，也可以继续实现runnable接口
       2.实现接口，进行接口的开发中可以进行功能方法的扩展，数据有效分离
       3.共享同一个资源，更加提高了资源的使用效率，可以同时处理一个资源
3.什么是线程同步?为什么我们需要线程同步?
线程同步：当某个线程拿到资源以后，必须等待该线程处理完这个资源后，下个线程才能继续执行，通过锁的机制，实现线程的同步，为了避免并发问题的发生

4.Java中有哪些是线程安全的?举3个例子并说明
一：使用同步代码块
二：静态函数同步
三：线程死锁
5.什么是Lock锁?
当多个线程需要访问某个公共资源的时候，我们知道需要通过加锁来保证资源的访问不会出问题
Reentrant.lock()方法
6.讲讲今天的生产者和消费者的案例?
经典的供求案例：生产者负责生产一个完整的数据之后，消费者就要把这些数据取走
问题一：解决重复问题：如果要想解决同步问题，那么可以立刻想到使用synchronized关键字来定义同步的操作方法
问题二：解决数据的重复操作问题：如果想要解决重复问题，就要添加唤醒和等待机制，如果想使用这一个功能，那么就要参考Object类中的方法
使用中含有： sleep()是Thread类的方法到了一定的时间后该休眠自动唤醒
　　         wait()是Object类中的方法，要想唤醒必须使用notify(),notifyAll()

1.自己说说什么是进程,什么线程?
进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。
线程是进程的一部分，线程是进程中最小的单位（不可在分割）。
2.实现多线程有几种方式?分别是什么?
自定义线程类 继承Thread
自定义线程类 实现Runnable接口
3.什么是线程同步?为什么我们需要线程同步?
线程同步：是多个线程同时访问同一资源，等待资源访问结束，浪费时间，效率低。
好处：解决了线程的安全问题。
4.Java中有哪些是线程安全的?举3个例子并说明
HashTable -> HashMap StringBuffer -> StringBuilder Vector -> ArrayList
5.什么是Lock锁?
lock 确保当一个线程位于代码的临界区时，另一个线程不进入临界区。
6.讲讲今天的生产者和消费者的案例?
重点是wait和notifyAll 方法，前者是当前线程进入到睡眠状态，后者使除当前线程外的所有线程都被唤醒。

今日整理:
1.自己说说什么是进程,什么线程?
进程就是计算机在运行中的程序        线程就是进程中可同时进行的操作数  单线程就是只能干一件事   多线程可以同时干多件事
2.实现多线程有几种方式?分别是什么?
实现多线程的方式有两种，一种是类继承Thread 重写run方法 然后使用start方法启动        另一种是实现runnable接口 重写run方法  然后将对象传入到Thread的有参构造方法中当参数 使用Thread对象的start方法启动
3.什么是线程同步?为什么我们需要线程同步?
线程同步就是当一个线程在对一块内存进行操作时  其他线程不能参与操作  要等待第一个线程结束后才可以参与。 内存同步可以解决并发问题所以我们需要线程同步。
4.Java中有哪些是线程安全的?举3个例子并说明
StringBuffer是操作字符串的  他的方法用synchronized修饰      vector是操作java数组的          hashtable跟hashmap相同 不过他是线程安全的。

5.什么是Lock锁?
lock锁是一个接口   可以使用它的实现类 ReentrantLock 中的方法 lock() unlock()  得到跟synchronized一样的效果
6.讲讲今天的生产者和消费者的案例?
今天的生产者消费者案例
生产者消费者  都要操作奶箱  所以是对奶香里面的属性进行修改
所以奶箱类里应有牛奶瓶数   比如放牛奶 取牛奶
生产者消费者作为操作对象要实现runnable接口
生产者消费者重写的run方法应进行与奶箱有关的相关操作
如果奶箱最多只能放五个牛奶   生产者将无法再往里面放入牛奶  所以奶箱的存取牛奶应该对牛奶的所剩个数进行判断  如果奶箱里牛奶满了 则生产者等待  使用notifyall()唤醒消费者
如果奶箱里面牛奶为零个 消费者则需要等待 使用notifyall()唤醒生产者  生产者消费者调用run方法之前都需要判断箱子里的牛奶瓶数  使用wait()方法。

1.进程是资源分配的基本单位，线程是程序执行的最小单位，是进程的一个执行流，一个线程由多个线程组成。
2.两种。 分别是：继承Thread类 ；实现Runnable接口
3.是多个线程同时访问同一资源。解决了线程的安全问题。
4.线程安全就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问直到该线程读取完，其他线程才可使用。
5.lock锁住的是ock()和unlock()之间的代码块。
6.就是两个线程调用调用共区域

1.自己说说什么是进程,什么线程?
进程就是计算机正在执行的程序，它是系统进行资源分配的基本单位
线程是进程的一部分，它是进程中的单个顺序控制流，是一条执行路径，线程是进程的最小单位。
进程是线程的容器
2.实现多线程有几种方式?分别是什么?
方式一：继承Thread并重写run()，并调用start();
方式二：实现Rannable接口，并用其初始化Thread，然后创建Thread实例，并调用start()；
方式三：实现Callable接口，并用其初始化Thread，然后创建Thread实例，并调用start();
方式四：使用线程池创建
3.什么是线程同步?为什么我们需要线程同步?
当多个线程同时读写同一份共享资源的时候，可能会引起冲突。这时候，我们需要线程同步，即各位线程之间要有个先来后到几个线程之间要排队，一个一个对共享资源进行操作
4.Java中有哪些是线程安全的?举3个例子并说明
StringBuffer是线程安全，可变的字符序列
ArrayList和HashMap是异步的，
Vector和HashTable是同步的
List本身是一个接口，有一个类叫Vector，它实现了List，并且这个Vector是线程同步的
5.什么是Lock锁?
Lock锁实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作
6.讲讲今天的生产者和消费者的案例?
生产者和消费者案例是一个多线程协作模式。
案例中有两个线程：一个是生产者线程用于生产数据；一类是消费者线程用于消费数据他们采用的共享数据区域可以看成是一个仓库；生产者生产数据直接放在仓库中，与消费者无关，消费者直接从仓库中获取数据，
与生产者无关。但当仓库中有数据没被消费时，生产者会提醒消费者来获取数据，同理如果仓库中没有数据，消费者会提醒生产者生产数据，这就是Java中的等待wait()和唤醒notifyAll()问题.

今日整理:
1.自己说说什么是进程,什么线程?
进程就是系统中正在执行的程序，线程就是进程的一部分。
2.实现多线程有几种方式?分别是什么?
实现多线程有两种方式；①自定义线程类继承Thread（多线程无法处理一个资源）；②自定义线程类实现Runnable接口（多线程可以处理一个资源）
3.什么是线程同步?为什么我们需要线程同步?
线程同步就是让几个线程依次对共享资源进行操作，可以避免同时执行共享的资源。
4.Java中有哪些是线程安全的?举3个例子并说明
①StringBuffer②Vector③Hashtable
5.什么是Lock锁?
Lock锁是JDK5以后提供了一个新的锁对象Lock,效果和关键字（Synchronized）一样，但可以手动上锁解锁。
6.讲讲今天的生产者和消费者的案例?
生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻。
其中生产者和消费者都是线程，共享资源就是奶箱。

1.自己说说什么是进程,什么线程?
进程：计算机中正在执行的程序，系统进行资源分配的基本单位同时也是线程的容器。
线程：线程是进程的一部分，线程是进程中最小的单位
2.实现多线程有几种方式?分别是什么?
两种方式；1、继承Thread类。2、继承Thread类。
3.什么是线程同步?为什么我们需要线程同步?
是多个线程同时访问同一资源，等待资源访问结束，浪费时间，效率低
线程的同步解决了线程的安全问题。
4.Java中有哪些是线程安全的?举3个例子并说明
StringBuffer：线程安全，可变的字符序列、Vector：该类改进了List接口，使其成为Java Collections Framework的成员、
Hashtable：该类实现了一个哈希表，它将键映射到值。 任何非null对象都可以用作键或者值
5.什么是Lock锁?
更加清晰表达同步代码块和同步方法如何加锁和释放锁。
6.讲讲今天的生产者和消费者的案例?
生产者消费者模式是一个十分经典的多线程协作的模式，
一类是生产者线程用于生产数据、一类是消费者线程用于消费数据、
生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为、消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为、生产者和消费者两者互不干扰。

1.自己说说什么是进程,什么线程?
进程是正在运行的程序
线程是进程中的单个顺序控制流，是一条执行路径

2.实现多线程有几种方式?分别是什么?
有两种方法
分别是1.继承Thread类 2.实现Runnable接口
3.什么是线程同步?为什么我们需要线程同步?
锁多条语句操作共享数据，
因为线程同步可以解决多线程的安全问题
4.Java中有哪些是线程安全的?举3个例子并说明
Vector、HashTable、Properties是线程安全的
5.什么是Lock锁?
虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，jdk5以后提供了一个新的锁对象lock
6.讲讲今天的生产者和消费者的案例?
主要一类是生产者线程用于生产数据，生产者生产数据之后直接放在共享数据区中，并不关心消费者的行为
一类是消费者线程用于消费数据，消费者只需要从共享数据区中去获取数据，并不关心生产者的行为

今日整理:
1.自己说说什么是进程,什么线程?
答：进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，
是系统进行资源分配和调度的基本单位，是操作系统结构的基础。
在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；
在当代面向线程设计的计算机结构中，进程是线程的容器。
线程（thread）是操作系统能够进行运算调度的最小单位。
它被包含在进程之中，是进程中的实际运作单位。
2.实现多线程有几种方式?分别是什么?
答：多线程有两种实现方法，分别是继承Thread类与实现Runnable接口
3.什么是线程同步?为什么我们需要线程同步?
答：是多个线程同时访问同一资源，解决了线程的安全问题
4.Java中有哪些是线程安全的?举3个例子并说明
答：Vector 线程安全：HashTable 线程安全：StringBuffer 线程安全：
5.什么是Lock锁?
答：确保当一个线程位于代码的临界区时，另一个线程不进入临界区。
如果其他线程试图进入锁定的代码，则它将一直等待（即被阻止），直到该对象被释放。
6.讲讲今天的生产者和消费者的案例?
答：首先创建一个共享的奶箱对象
然后创建一个消费者和一个生产者对象，把奶箱作为参数传递进去，以便于调用奶箱中的方法。
接着创建一个测试类，创建两个线程对象，分别把消费者和生产者作为构造方法参数传递进去
最后启动线程。

今日整理:
1.自己说说什么是进程,什么线程?

进程：是系统进行资源分配的基本单位
线程：线程是不能脱离进程存在的最小单位

2.实现多线程有几种方式?分别是什么?

2种
方式一：
public class MyThread1 extends  Thread{
    @Override
    public void run() {
        //code
    }
}

方式二：
public class MyThread2 implements Runnable {
    @Override
    public void run() {
        //code
    }
}

3.什么是线程同步?为什么我们需要线程同步?

线程同步：当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，
其他线程才能对该内存地址进行操作，而其他线程又处于等待状态

原因：解决多线程的数据安全问题

4.Java中有哪些是线程安全的?举3个例子并说明

Vector
Hashtable
StringBuffer

5.什么是Lock锁?

Lock是接口不能直接实例化
Lock锁与synchronized一样，都是可以用来控制同步访问的

6.讲讲今天的生产者和消费者的案例?

生产者和消费者共同操作一个容器，而并不需要关心对方的行为

生产者：如果容器内没有物品了，则生产者进行生产，并修改状态标识符，同时唤醒其他线程；如果容器内有物品，则生产者进入等待状态
消费者：如果容器内有物品，则消费者取走物品，修改状态标识符，同时唤醒其他线程；如果容器内没有物品，则消费者进入等待状态

今日整理:
1.自己说说什么是进程,什么线程?

        一个运行的程序就是进程，进程里面执行单线程或者多线程。

2.实现多线程有几种方式?分别是什么?

        两种。
        一种是类继承Thread。
        一种是类实现Runnable。

3.什么是线程同步?为什么我们需要线程同步?

        线程同步就是只能有一个线程执行同步的代码块。
        解决并发异常问题。

4.Java中有哪些是线程安全的?举3个例子并说明

        Vector集合
        StringBuffer
5.什么是Lock锁?
        效果同同步代码块，有线程进入的时候lock锁上，lock后面的代码块只能一个线程执行，执行完毕后unlock解锁。其他线程可以进入。
       
6.讲讲今天的生产者和消费者的案例?
        运用了多种方法。很好

1.- 进程：是正在运行的程序
          是系统进行资源分配和调用的独立单位
          每一个进程都有它自己的内存空间和系统资源
   - 线程：是进程中的单个顺序控制流，是一条执行路径
          单线程：一个进程如果只有一条执行路径，则称为单线程程序
          多线程：一个进程如果有多条执行路径，则称为多线程程序

2.继承Thread类
   实现Runnable接口

3.线程同步：有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作

  线程有可能和其他线程共享一些资源，比如，内存，文件，数据库等。当多个线程同时读写同一份共享资源的时候，
  可能会引起冲突。这时候，我们需要引入线程“同步”机制，即各位线程之间要有个先来后到

4.JAVA中线程安全的map有：Hashtable、synchronizedMap、ConcurrentHashMap。
java中map中线程安全怎么实现：
1、同步的map就是Hashtable, concurrenthashmap。
2、你看到的Hashtable就是直接在hashmap上加了个锁，concurrenthashmap就是分成多个分段锁

5.Lock是一个接口，可以让等待锁的线程响应中断

1.自己说说什么是进程,什么线程?
   进程就是计算机中正在执行的程序；
   线程是进程的一部分，线程是进程中最小的单位
2.实现多线程有几种方式?分别是什么?
   方式一：继承Thread类
   方式二：实现Runnable接口
3.什么是线程同步?为什么我们需要线程同步?
   线程同步：是多个线程同时访问同一资源
   使用线程同步可以解决线程得安全问题。
4.Java中有哪些是线程安全的?举3个例子并说明
   Vector，StringBuffer和Hashtable
5.什么是Lock锁?
   Lock实现提供比使用synchronized方法和语句可以获得的更广泛的锁定操作。
   它们允许更灵活的结构化，可能具有完全不同的属性，并且可以支持多个关联的Condition对象。
6.讲讲今天的生产者和消费者的案例?
   生产者和消费者案例是典型的多线程问题。生产者和消费者共享同一个资源，生产者将东西放进
   共享区域里再由消费者去获取。

1.自己说说什么是进程,什么线程?
答:进程是在内存中正在运行的程序.
    线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位.
2.实现多线程有几种方式?分别是什么?
答:两种
    第一种方式：继承Thread类。
        第二种方法：实现Runnable接口。

3.什么是线程同步?为什么我们需要线程同步?
答:线程同步是定义一个锁,让线程拿到锁之后,运行完整个代码块才释放锁.
    同步代码块解决数据安全问题.
4.Java中有哪些是线程安全的?举3个例子并说明
  答:- StringBuffer,Vector,Hashtable
5.什么是Lock锁?
  答:Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化,可以直接调用方法获取锁,和释放锁.
6.讲讲今天的生产者和消费者的案例?
  答:生产一个,消费一个.

今日整理:
1.自己说说什么是进程,什么线程?
答：
进程：
*是正在运行的程序
*是系统进行资源分配和调用的独立单位
*每一个进程都有它自己的内存空间和系统资源

线程：
*是进程中的单个顺序控制流，是一条执行路径
*单线程：一个进程如果只有一条执行路径，则称为单线程程序（一次只能执行一个任务）
*多线程：一个进程如果由多条执行路径，则称为多线程程序（同时可以执行多个任务）


2.实现多线程有几种方式?分别是什么?
答：
实现多线程的方式有两种：

方式一：继承Thread类
*实现步骤：
……定义一个类MyThread继承Thread类
……在MyThread类中重写run()方法
……创建MyThread类的对象
……通过对象调用start（）方法来启用线程

方式二：
*实现步骤：
……定义一个类MyRunnable实现Runnable接口
……在MyRunnable类中重写run（）方法
……创建MyRunnable类的对象
……创建Thread类的对象，把MyRunnable对象作为构造方法的参数传进去
……通过Thread对象的start方法启动线程

相比继承Thread类，实现Runnable接口的好处
……避免了Java单继承的局限性
……适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效的分离，较好的体现了面向对象的设计思想


3.什么是线程同步?为什么我们需要线程同步?
答：
线程同步：
线程同步的真实意思和字面意思恰好相反。线程同步的真实意思，其实是“排队”：几个线程之间要排队，一个一个对共享资源进行操作，而不是同时进行操作。

为什么需要线程同步：
当多个线程同时读写同一份共享资源的时候，可能会引起冲突。这时候，我们需要引入线程“同步”机制，即各位线程之间要有个先来后到，不能一窝蜂挤上去抢作一团。

线程同步的方法：
(1)wait():使一个线程处于等待状态，并且释放所持有的对象的lock。
(2)sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。
(3)notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。
(4)notityAll ():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争


4.Java中有哪些是线程安全的?举3个例子并说明
答：
*StringBuffer
……线程安全，可变的字符序列
……从版本JDK5开始，被StringBuilder替代，通常应该使用StringBuilder类，因为它支持所有相同用的操作，但它更快，因为它不执行同步

*Vector
……从Java2平台v1.2开始，该类改进了List接口，使其成为Java Collections Framework的成员，与新的集合实现不同，Vector被同步，如果不需要线程安全的实现，建议使用ArrayList代替Vector

*Hashtable
……该类实现了一个哈希表，它将键映射到值，任何非null对象都可以用作键或者值
……从Java2平台v1.2开始，该类进行了改进，实现了Map接口，使其成为Java Collections Framework的成员。与新的集合实现不同，Hashtable被同步，如果不需要线程安全的实现，建议使用HashMap代替Hashtable


5.什么是Lock锁?
答：
虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock
Lock是接口，不能直接实例化 ，这里采用它的实现类ReentrantLock来实例化


6.讲讲今天的生产者和消费者的案例?
答：

生产者消费者案例中包含的类：

奶箱类(Box)：定义一个成员变量，表示第x瓶奶，提供存储牛奶和获取牛奶的操作
（将成为生产者和消费者的参数，其实也定义了获取和存储牛奶的操作）
生产者类(Producer)：实现Runnable接口，重写run()方法，调用存储牛奶的操作
（一个子线程，run方法中可以通过传进来的奶箱参数获取奶箱类中定义的方法）
消费者类(Customer)：实现Runnable接口，重写run()方法，调用获取牛奶的操作
（一个子线程，run方法中可以通过传进来的奶箱参数获取奶箱类中定义的方法）
测试类(BoxDemo)：里面有main方法，main方法中的代码步骤如下

①创建奶箱对象，这是共享数据区域

②创建消费者创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作

③对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作

④创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递

⑤启动线程

1.进程是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。  线程是进程的一部分，线程是进程中最小的单位
2。两种
一种是定义一个类继承Thread，重写run()方法封装线程运行的代码，然后通过创建类对象创建线程，用start方法开启线程；
第二种是定义一个类实现Runable接口，重写run()方法封装线程运行的代码，然后在主方法创建类对象，再由这个类对象做参数创建一个Thread对象为线程，通过start()方法开启线程。
3.线程同步就是当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，用来解决线程并发问题
4.Vector ，HashTable ，StringBuffer
5.就是锁定这个代码块，可以得到和 synchronized一样的效果，Lock实现提供比使用synchronized方法和语句可以获得的更广泛的锁定操作,当有一个线程进入时，锁定，使其他线程无法进入，lock锁提供了几种方法，用lock()方法进行上锁，unlock()方法进行解锁
6.创建生产者和消费者类，重写run()方法封装各自的线程运行代码，生产者类的run方法封装的是调用放牛奶的方法，消费者类的run方法封装的是调用取牛奶的方法，创建一个奶箱类，提供存牛奶和放牛奶的方法，数据在这个类里操作，使用同步方法，配合wait()以及notify()方法实现两个线程之间的数据操作，并且避免线程并发，最后在主方法开启两个线程