（五）Lock锁的用法||Lock锁与 synchronized 关键字的区别

Lock锁的用法

Lock锁机制与 synchronized 关键字的区别

---

一、Lock锁的用法

Lock lock = new ReentrantLock();
lock.lock();
try{
//可能会出现线程安全的操作
}finally{
//一定在finally中释放锁
//也不能把获取锁在try中进行，因为有可能在获取锁的时候抛出异常
lock.unlock();
}

二、Lock锁机制与 synchronized 关键字的区别：

1. synchronized修饰的同步代码块其实自身是具有自动上锁、自动解锁功能的；
   Lock锁机制则是手动解锁，手动上锁的；

2. 用synchronized修饰的同步代码块还有同步方法是有同步锁对象的；
   Lock锁机制是没有同步锁对象的；

3. 因为synchronized修饰的同步代码块还有同步方法是具有锁对象的，因此，可以
   调用notify()、wait()、notifyAll()的方法；

   但是因为Lock锁机制是不具有锁对象的，因此是不可以去调用notify()、wait()、
   notifyAll()方法的；
   那么如果Lock锁机制一定要使用等待唤醒机制的话，在Java5之后，我们只能通过创建一个Condition类对象，然后通过该对象来调用await()、signal()、signAll()方法，而这几个方法的作用跟notify()、wait()、notifyAll()是一样功能的；

三、Condition用法

Condition的功能类似于在传统的线程技术中的Object.wait()和Object.notify()的功能。

Condition condition = lock.newCondition();
user. condition.await(); 类似wait
user. Condition. Signal() 类似notify

四、代码示例

共享资源源实体类

/**
 共享资源源实体类
 */
class UserInfo {
    public String userSex;
    public String userName;
    /**手动lock锁*/
    Lock lock= new ReentrantLock();
    /**Condition功能*/
    Condition condition=lock.newCondition();
    /**线程通讯标识
     * true:让生产者进行等待，消费者进行消费
     * false：生产者可以生产，消费者进行等待
     * */
    public boolean flag=false;
}

输入线程资源

public class InputThread extends Thread{
    private UserInfo user;
    //构造函数
    public InputThread (UserInfo user){
        this.user=user;
    }
    @Override
    public void run() {
        int count=0;
            while (true){
                //开始手动上锁
                user.lock.lock();

                try {
                    //当flag为true时（注意：在判断条件里if(user.flag)等价于if(user.flag==true)）
                    if (user.flag) {
                        //让当前线程 从运行状态变为休眠状态，并且释放锁的资源
                        user.condition.await();
                    }
                    //1.当线程第一次运行时，flag为false，先进行生产
                    if(count==0){
                            user.userName="大圣";
                            user.userSex="男";
                        }else{
                            user.userName="小红";
                            user.userSex="女";
                        }
                    //计算奇数或者偶数公式
                    count=(count+1)%2;
                    //2.当第一个线程生产完的时候，把flag状态改为true，
                    // 即让生产者线程处于等待状态，让消费者进行读取
                    user.flag=true;
                    //唤醒当前等待的线程，否则你只能打印一条
                    user.condition.signal();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    //手动释放锁
                    user.lock.unlock();
                }

            }
    }
 }

输出线程资源

public class OutputThread extends Thread{

    private UserInfo user;
    //构造函数
    public OutputThread(UserInfo user){
        this.user=user;
    }
    @Override
    public void run() {
        while (true) {
            //开始手动上锁
            user.lock.lock();
            try {
                //当flag为false时（注意：在判断条件里if(!user.flag)等价于if(user.flag==false)）
                if (!user.flag) {
                    //让当前线程 从运行状态变为休眠状态，并且释放锁的资源
                    user.condition.await();
                }
                //3.进来时，flag为true，消费者进行消费，生产者进行等待
                System.out.println("userName:"+user.userName+"----userSex:"+user.userSex);
                //4.消费者读取完后，把flag状态改为false，再去生产者那边生产，待在消费者这里也没用
                user.flag=false;
                //唤醒当前等待的线程，否则你只能打印一条
                user.condition.signal();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                //手动释放锁
                user.lock.unlock();
            }


        }
    }

}

运行代码：

 UserInfo user=new UserInfo();
        //构造方法就是在这里用的
        //两个线程共享同一变量
        InputThread it=new InputThread(user);
        OutputThread ot=new OutputThread(user);
        it.start();
        ot.start();

运行结果：