首页 > 代码库 > 通过Lock对象以及Condition对象实现多线程同步

通过Lock对象以及Condition对象实现多线程同步

 

通过Lock对象以及Condition对象实现多线程同步:

在之前的学习中,无论是通过synchronized建立同步代码块,还是通过synchronized建立同步函数,都是把对象看成一把锁来实现同步,这种解释有点牵强,而且在消费者—生产者的那个实例中,其实还有个问题,那就是在避免线程全部冻结时,没必要把相同功能的线程解冻,只要把其他功能的线程解冻即可,也就是说消费者线程只要解冻生产者线程即可,没必要把其他消费者线程也解冻,为了解决这些问题,java1.5版本推出了同步的升级办法,那就是通过Lock对象和Condition对象实现同步。

新的同步办法不再需要synchronized关键字,而引入了更加形象的Lock。

Lock实质上是是一个接口,在创建对象时,使用Lock的子类ReentrantLock来建立对象。

使用方法:建立对象后,在需要同步的代码前一行写    Lock对象.lock();   ,在同步代码后一行写   Lock对象.unlock();

Lock对象用来控制线程的进出,而对线程的操作则由Condition对象来操作;

对应关系:

wait——await(两者均抛出异常)

notify——signal

notifyAll——signalAll

Condition同样是接口,建立方法(比较神奇)       Condition 对象名=Lock对象.newCondition();

 

例如:1-9 个数,A线程执行123.然后由B线程接着执行456.最后在由A线程执行789

代码:

package com.huojg.test;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/*
 * 
 * 1-9 个数,A线程执行123.然后由B线程接着执行456.最后在由A线程执行789
 * 
 * 
 * **/
public class lock {
    static class NumberWrapper {
        public int value = http://www.mamicode.com/1;
    }
    
public static void main(String[] args) {
    
    //初始化可重入锁
    final Lock lock=new ReentrantLock();
    //第一个条件当屏幕上输出到3
    final Condition reachThreeCondition=lock.newCondition();
    //第一个条件当屏幕上输出到6
    final Condition reachSixCondition=lock.newCondition();     
    //NumberWrapper只是为了封装一个数字,一边可以将数字对象共享,并可以设置为final
            //注意这里不要用Integer, Integer 是不可变对象
            final NumberWrapper num = new NumberWrapper();
    //初始化A线程
    Thread threadA=new Thread( new Runnable() {
        public void run() {
            //需要先获得锁
            lock.lock();
            try {
                System.out.println("threadA start write");
                while (num.value<=3) {
                    System.out.println(num.value);
                    num.value++;                    
                }
                //输出到3时要signal,告诉B线程可以开始了
                reachThreeCondition.signal();
            } finally{
                lock.unlock();
            }
            
            lock.lock();
            try {
                //等待输出6的条件
                reachSixCondition.await();
                System.out.println("threadA start write");
                //输出剩余数字
                while (num.value <= 9) {
                    System.out.println(num.value);
                    num.value++;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }                
        }
    });
    
    Thread threadB =new Thread(new  Runnable() {
        public void run() {
        try {
            lock.lock();
            while (num.value<=3) {
                //等待3输出完毕的信号
                reachThreeCondition.await();
            }
            
        }catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
            
            
        try {
            lock.lock();
            //已经收到信号,开始输出4,5,6
            System.out.println("threadB start write");
            while (num.value <= 6) {
                System.out.println(num.value);
                num.value++;
            }
            //4,5,6输出完毕,告诉A线程6输出完了
            reachSixCondition.signal();
            
        } finally{
            lock.unlock();
        }
            
        }
    });

    //启动两个线程
            threadB.start();
            threadA.start();    

}

}

 

结果:

threadA start write
1
2
3
threadB start write
4
5
6
threadA start write
7
8
9

  

Condition对象的优势在于,signal只能唤醒被相同Condition对象的await方法冻结的线程,因此,可以建立多个Condition对象,分别用来冻结和解冻不同功能的线程

最后要注意的是,Lock接口属于类包Java.util.concurrent.locks

 

通过Lock对象以及Condition对象实现多线程同步