Lock的使用

本是古典何须时尚 2022-06-08 00:35 167阅读 0赞

Lock的使用  
1.使用ReentrantLock类  
    \* 在java多线程中，可以使用synchronized关键字来实现线程之间同步互斥，但在JDK1.5中新增加了ReentrantLock类  
        也能达到同样的效果，并且再扩展功能上也更加强大，比如有嗅探锁定，多路分支通知等功能，而且在使用上也比  
        synchronized更加的灵活。  
  
  
    \*使用ReentrantLock实现同步

举个栗子：

public class MyService {
        private Lock lock=new ReentrantLock();
        public void testMethod(){
            lock.lock();
            for(int i=0;i<5;i++){
                System.out.println("ThreadName="+Thread.currentThread().getName()+(""+(i+1)));
            }
            lock.unlock();
        }
    }

public class MyThread extends Thread {
        private MyService myService;
        public MyThread(MyService myService){
            super();
            this.myService=myService;
        }
    
        @Override
        public void run() {
            myService.testMethod();
        }
    }

public class Run {
        public static void main(String[] args) {
            MyService service = new MyService();
            MyThread a1 = new MyThread(service);
            MyThread a2 = new MyThread(service);
            MyThread a3 = new MyThread(service);
            MyThread a4 = new MyThread(service);
            MyThread a5 = new MyThread(service);
            a1.start();
            a2.start();
            a3.start();
            a4.start();
            a5.start();
        }
    }

很简单，使用lock加锁，unlock解锁

\* 使用Condition实现等待/通知  
        关键字synchronized与wait()和notify()/notifyAll()方法相结合可以实现等待/通知模式，类ReentrantLock也  
        可以实现同样的功能，但需要借助于Condition对象。Condition类是在JDK5中出现的技术，使用它有更好的灵活性，  
        比如可以实现多路通知功能，也就是在一个Lock对象里面可以创建多个Condition(即对象监视器)实例，线程对象可以  
        注册在指定的Condition中，从而可以有选择性地进行线程通知，在调度线程上更加灵活。  
        注意：在调用condition.await()方法前，必须用lock.lock()代码获取同步监视器。  
  
  
        \* 使用Condition实现等待/通知

举个栗子

public class MyService {
        private Lock lock = new ReentrantLock();
        public Condition condition = lock.newCondition();
    
        public void await() {
            try {
                lock.lock();
                System.out.println(" await时间为" + System.currentTimeMillis());
                condition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    
        public void signal() {
            try {
                lock.lock();
                System.out.println("signal时间为 " + System.currentTimeMillis());
                condition.signal();
            } finally {
                lock.unlock();
            }
        }
    }

public class ThreadA extends Thread {
        private MyService service;
    
        public ThreadA(MyService service) {
            super();
            this.service = service;
        }
    
        @Override
        public void run() {
            service.await();
        }
    }

public class Run {
        public static void main(String[] args) throws InterruptedException {
            MyService service = new MyService();
            ThreadA a = new ThreadA(service);
            a.start();
            Thread.sleep(3000);
            service.signal();
        }
    }

\*使用多个Condition实现通知部分线程

public class MyService {
        private Lock lock = new ReentrantLock();
        public Condition conditionA = lock.newCondition();
        public Condition conditionB = lock.newCondition();
    
        public void awaitA() {
            try {
                lock.lock();
                System.out.println("begin awaitA时间为" + System.currentTimeMillis() + "ThreadName=" + Thread.currentThread().getName());
                conditionA.await();
                System.out.println(" end awaitA时间为" + System.currentTimeMillis() + " ThreadName=" + Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    
        public void awaitB() {
            try {
                lock.lock();
                System.out.println("begin awaitB时间为 " + System.currentTimeMillis() + " ThreadName=" + Thread.currentThread().getName());
                conditionB.await();
                System.out.println(" end awaitB时间为 " + System.currentTimeMillis() + " ThreadName=" + Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    
        public void signalAll_A() {
            try {
                lock.lock();
                System.out.println(" signalAll_A时间为" + System.currentTimeMillis() + " ThreadName=" + Thread.currentThread().getName());
                conditionA.signalAll();
            } finally {
                lock.unlock();
            }
        }
    
        public void signalAll_B() {
            try {
                lock.lock();
                System.out.println(" signalAll_B时间为" + System.currentTimeMillis() + " ThreadName=" + Thread.currentThread().getName());
                conditionB.signalAll();
            } finally {
                lock.unlock();
            }
        }
    
    }

测试后，只有线程A被唤醒了。使用ReentrantLock对象可以唤醒指定种类的线程，这是控制部分线程行为的方便方式。

\*公平锁与非公平锁  
        公平与非公平锁：锁Lock分为 "公平锁”和"非公平锁",公平锁表示线程获取锁的顺序是按照线程加锁的顺序来分配的，  
        即先来先得的FIFO先进先出顺序。而非公平锁就是一种获取锁的抢占机制，是随机获得锁的，和公平锁不一样的就是先来的  
        不一定先得到锁，这个方式可能造成某些线程一直拿不到锁，结果也就是不公平的了。  
        lock =new ReentrantLock(true);//公平锁  
        lock =new ReentrantLock(false);//非公平锁