处理线程同步出现的数据不对等问题，以及加入锁机制后的问题

在多线程中处理安全问题。
通常有3种方法，同步方法，同步块，Lock（锁，1.5版本开始使用）存在JUC包下。在ReentrantLock（可重入锁，常用）
同步方法通过synchronize关键字来对方法进行锁定。锁定对象是this
同步块同上，但锁定的对象是锁定变量的增删改的行为。

JUC里面的copyonwriterArraylist是通过 volatile 、transient关键字和Reentrantlock进行锁控制。

通过Reentranlock锁能直接显式的加锁和解锁。（通过try finally来执行）

加入锁级之后会出现的死锁情况。

死锁，就是多个线程之间的僵持，互相拿着对方需要的锁，形成互相等待其他线程占有的资源。
产生死锁的4 个条件：
互斥条件：一个资源只能被一个进程使用
请求与保持：一个进程被阻塞，不释放已有资源
不剥夺：不能强行剥夺进程中已获得的资源
循环等待：进程之间形成一种头尾相接的循环等待。
想要破除其中任意一个条件就能避免死锁。

class A{
	private final ReentrantLock lock = new ReenTrantLock();
	public void m(){
	//显式加锁
		lock.lock();
		try{
			//保证线程安全的代码
		}finally{
		//显式解锁
			lock.unlock();
		}
	}

synchronize 和 Lock的对比：
1、显隐式锁 前者是隐式锁，后者是显式锁。
2、Lock只能锁代码，而synchronizeed有代码锁和方法锁。
3、JVM花费较少的时间来调度线程，性能更好

wait、notify都是针对于当前的对象的锁而言的。如果是1个生产1个消费，那么刚刚好会再释放锁的同时，被另一方抢到，而如果是1个生产2个消费，则会出现释放锁的同时，可能会出现被消费者抢到。这样角标就越界了。
如果使用的是notifyall，是唤醒所有对象。
解决的方式是将方法中的if判断转变为while判断。在唤醒的时候，再检查一遍count的值是否符合要求。
生产者和消费者

package com.ht.Thread.com.buyticket.syn;

import java.sql.Connection;
import java.util.concurrent.locks.ReentrantLock;

public class TestPC {

    public static void main(String[] args) {
//        TestPC testPC = new TestPC();
        Container chickenContain = new Container();

        Productor productor = new Productor(chickenContain);
        Consumer consumer = new Consumer(chickenContain);
        Consumer consumer1 = new Consumer(chickenContain);

        new Thread(productor).start();
        new Thread(consumer).start();
        new Thread(consumer1).start();
    }
}

class Chicken{

    int id;
    public Chicken(int id){
        this.id = id;
    }

}

//这里不是继承Runnable，而是继承Thread
//生产者
class Productor extends Thread{

    Container contain;
    ReentrantLock lock = new ReentrantLock();
    public Productor(Container contain){

        this.contain = contain;
    }

    @Override
    public void run() {
        for (int i = 0; i < 8; i++) {
            System.out.println("生产了"+ i+ "只鸡");
            contain.produce(new Chicken(i));
        }
    }
}

//消费者
class Consumer extends Thread{
    Container contain;
    public Consumer(Container contain){

        this.contain = contain;
    }

    ReentrantLock lock =  new  ReentrantLock();
    @Override
    public void run() {
        for (int i = 0; i < 4; i++) {
            System.out.println(
            Thread.currentThread().getName()+"消费了-->"
            +contain.consume().id+"只鸡");
        }
    }
}

class Container{

    Chicken[] chickens = new  Chicken[4]; //直接创建自定义对象的数组
    int count = 0;



//    生产方法
    public synchronized void produce(Chicken newChicken){

        while(count == chickens.length){
//            当容器满了，则生产等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
//        如果生产者没满，则需要丢入生产者

        chickens[count] = newChicken;
        count++;
//        通知消费者消费
        this.notifyAll();
    }
//    消费函数
    public synchronized Chicken consume(){
//        当没有库存的时候，等待生产者生产
        while (count ==0){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
//        先自减。
        --count;
        Chicken chicken = chickens[count];
//        当库存没了，就通知生产。
        notifyAll();
        return chicken;

    }
}