Java学习之线程通信（多线程（Lock））--生产者消费者

SDK1.5版本以后对synchronized的升级，其思想是：将同步和锁封装成对象，其对象中包含操作锁的动作。

代码：

//1、导入包
import java.util.concurrent.locks.*;
class Resource
{
    private String name;
    private int count=1;
    private boolean flag=false;
    
    //创建互斥锁（相当于synchronized）
    Lock lock = new ReentrantLock();
    //创建锁对象（相当于Object对象）
    Condition producer_con = lock.newCondition();
    Condition consumer_con = lock.newCondition();
    
    public void set(String name) 
    {    
        lock.lock();
        try
        {
            while(flag)
                try{producer_con.await();}catch(InterruptedException e){}
            this.name=name+count;
            count++;
            System.out.println(Thread.currentThread().getName() + "...生产者..." + this.name);
            flag = true;
            consumer_con.signal();
        }
        finally
        {
            lock.unlock();
        }
    }
    
    public void out()
    {
        lock.lock();
        try
        {
            while(!flag)
                try{consumer_con.await();}catch(InterruptedException e){}
            System.out.println(Thread.currentThread().getName() + "==消费者==" + this.name);
            flag = false;
            producer_con.signal();
        }
        finally
        {
            lock.unlock();
        }
    }
}

//定义线程任务（生产者线程）
class Producer implements Runnable
{
    private Resource r;
    
    Producer(Resource r)
    {
        this.r=r;
    }
    public void run()
    {
        while(true)
        {
            r.set("商品");
        }
    }
}
//定义线程任务（消费者线程）
class Consumer implements Runnable
{
    private Resource r;
    
    Consumer(Resource r)
    {
        this.r=r;
    }
    
    public void run()
    {
        while(true)
        {
            r.out();
        }
    }
}

class ProducerConsumerDemo
{
    public static void main(String[] args)
    {
        //实例化共享资源
        Resource r = new Resource();
        //实例化线程任务，指定共享资源
        Producer p=new Producer(r);
        Consumer c=new Consumer(r);
        //实例化线程，指定线程任务
        Thread t0=new Thread(p);
        Thread t1=new Thread(p);
        Thread t2=new Thread(c);
        Thread t3=new Thread(c);
        //开启线程，执行线程任务中的run方法
        t0.start();
        t1.start();
        t2.start();
        t3.start();
    }
}

结果：

lock就是对同步的封装那就有关系和区别：