多线程学习--Lock

た入场券 2023-10-27 06:27 146阅读 0赞

Java多线程中国，可以使用synchronized关键字来实现线程之间的同步互斥，但是在jdk5之后新增加了lock也能达到同样效果，并且在扩展功能上也更加强大，比如具有嗅探锁定，多路分支通知等功能。

lock实现同步方式：

public class Myservice {
    
        private Lock lock=new ReentrantLock();
    
    
        public void getCount(){
    
            lock.lock();
    
            for (int i = 0; i <5 ; i++) {
                System.out.println(Thread.currentThread().getName()+"---"+(i++));
            }
            lock.unlock();
        }
    
        public static void main(String[] args) {
            Myservice myService=new Myservice();
    
            new Thread(() -> {
                myService.getCount();
            }).start();
            new Thread(() -> {
                myService.getCount();
            }).start();
            new Thread(() -> {
                myService.getCount();
            }).start();
            new Thread(() -> {
                myService.getCount();
            }).start();
            new Thread(() -> {
                myService.getCount();
            }).start();
        }
    }

结果：

Thread-0---0
    Thread-0---2
    Thread-0---4
    Thread-1---0
    Thread-1---2
    Thread-1---4
    Thread-2---0
    Thread-2---2
    Thread-2---4
    Thread-4---0
    Thread-4---2
    Thread-4---4
    Thread-3---0
    Thread-3---2
    Thread-3---4

lock实现等待唤醒：

lock可以实现等待唤醒机制，但是必须配合Condition对象，可以实现多路通知功能。也就是在一个lock对象里面可以创建多个Condition对象实例，线程对象可以注册在指定的Condition中，从而可以有选择性的进行线程通知，在调度上更加灵活。

Object类的wait()------Condition类的await()
      Object类的wait(long timeout)------Condition类的await(long time,TimeUnit unit)
      Object类的notify()------Condition类的signal()
      Object类的notifyAll()------Condition类的signalAll()

class ServiceC {
        private Lock lock = new ReentrantLock();
        private 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();
                System.out.println("锁释放了");
            }
        }
    
        public void signal() {
            try {
                lock.lock();
                System.out.println("signal时间为" + System.currentTimeMillis());
                condition.signal();
            } finally {
                lock.unlock();
            }
        }
    }
    public class test{
        public static void main(String[] args) throws InterruptedException {
            ServiceC service = new ServiceC();
            new Thread(()->{
                service.await();
            }).start();
            Thread.sleep(3000);
            service.signal();
        }
    }

结果：

await 时间为1544773054489
    signal时间为1544773057490
    锁释放了

lock可以唤醒指定的种类的线程，控制部分线程行为。

class MyService {
        private Lock lock = new ReentrantLock();
        private Condition conditionA = lock.newCondition();
        private Condition conditionB = lock.newCondition();
    
        public void awaitA() {
            try {
                lock.lock();
                System.out.println("awaitA begin时间为" + System.currentTimeMillis() + " ThreadName=" + Thread.currentThread().getName());
                conditionA.await();
                System.out.println("awaitA end  时间为" + System.currentTimeMillis() + " ThreadName=" + Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
                System.out.println("A锁释放了  时间为" + System.currentTimeMillis() + " ThreadName=" + Thread.currentThread().getName());
            }
        }
    
        public void awaitB() {
            try {
                lock.lock();
                System.out.println("awaitB begin时间为" + System.currentTimeMillis() + " ThreadName=" + Thread.currentThread().getName());
                conditionB.await();
                System.out.println("awaitB end  时间为" + System.currentTimeMillis() + " ThreadName=" + Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
                System.out.println("B锁释放了  时间为" + System.currentTimeMillis() + " ThreadName=" + Thread.currentThread().getName());
            }
        }
    
        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();
            }
        }
    }
    public class test{
        public static void main(String[] args) throws InterruptedException {
            MyService service = new MyService();
            new Thread(()->{
               service.awaitA();
            },"A").start();
           new Thread(()->{
               service.awaitB();
           },"B").start();
            Thread.sleep(3000);
            service.signalAll_A();
        }
    }

结果:

awaitA begin时间为1544773458416 ThreadName=A
    awaitB begin时间为1544773458416 ThreadName=B
    signalAll_A 时间为1544773461417 ThreadName=main
    awaitA end  时间为1544773461417 ThreadName=A
    A锁释放了  时间为1544773461417 ThreadName=A
     线程B还在等待状态

lock可以实现线程交替运行：

注意：signal() 用于一对一交替运行，多对多用signalAll()否则会出现假死现象。

公平锁与非公平锁：

公平锁：表示线程获取所得顺序是按照线程加锁的顺序来分配的，即先来先得的FIFO先进先出顺序。

非公平锁：获取锁的抢占机制，是所及获取的锁，和公平锁不一样的就是先来的不一定先得到锁，这个方式可能造成某些线程一直拿不到锁，结果也就是不公平了。

公平锁：

class Service {
        private ReentrantLock lock;
    
        public Service(boolean isFair) {
            this.lock = new ReentrantLock(isFair);
        }
    
        public void serviceMethod() {
            try {
                lock.lock();
                System.out.println("ThreadName=" + Thread.currentThread().getName() + "获得锁定");
            } finally {
                lock.unlock();
            }
        }
    
    }
    public class test{
        public static void main(String[] args) {
            final Service service = new Service(true);
    
            Runnable runnable = new Runnable() {
                public void run() {
                    System.out.println("★线程" + Thread.currentThread().getName() + "运行了");
                    service.serviceMethod();
                }
            };
    
            Thread[] threads = new Thread[10];
    
            for (int i = 0; i < 10; i++) {
                threads[i] = new Thread(runnable);
            }
    
            for (int i = 0; i < 10; i++) {
                threads[i].start();
            }
    
        }
    }

结果：

★线程Thread-0运行了
    ThreadName=Thread-0获得锁定
    ★线程Thread-1运行了
    ThreadName=Thread-1获得锁定
    ★线程Thread-2运行了
    ThreadName=Thread-2获得锁定
    ★线程Thread-3运行了
    ThreadName=Thread-3获得锁定
    ★线程Thread-4运行了
    ThreadName=Thread-4获得锁定
    ★线程Thread-5运行了
    ThreadName=Thread-5获得锁定
    ★线程Thread-6运行了
    ThreadName=Thread-6获得锁定
    ★线程Thread-8运行了
    ThreadName=Thread-8获得锁定
    ★线程Thread-7运行了
    ThreadName=Thread-7获得锁定
    ★线程Thread-9运行了
    ThreadName=Thread-9获得锁定

非公平锁：

实现方式： ReentrantLock lock=new ReentrantLock(false);

LockAPI：

getHoldCount()：查询当前线程保持此锁定的个数，即调用lock()方法的次数

getQueueLength()：返回正在等待获取此锁定的线程估计数

getWaitQueueLength(Condition condition)：返回等待与此锁定相关的给定条件Condition的线程估计数

hasQueueThread(Thread thread)：查询指定的线程是否正在等待获取此锁定

hasQueueThreads()：查询是否有线程正在等待获取此锁定

hasWaiters(Condition)：查询是否有线程正在等待与此锁定有关的condition条件

boolean isFair()：判断是不是公平锁

isHeldByCurrentThread()：查询当前线程是否保持此锁定

isLocked()：查询此锁定是否由任意线程保持

lockInterruptibly()：如果当前线程未被中断，则获取锁定，如果已经被中断则出现异常。lock.lockInterruptibly()

tryLock()：仅在调用时锁定（该锁并且未被另一个线程保持的情况下），才获取该锁定

tryLock(long timeout,TimeUnit unit)：如果该锁在指定的时间内没有被另一个线程获取并保持，且当前线程未被中断，则获取该锁

awaitUntil()**：****到达等待时间可唤醒自己**  new ReentrantLock().newCondition().awaitUntil();

class Service {
        private ReentrantLock lock = new ReentrantLock();
        private Condition condition = lock.newCondition();
    
        public void waitMethod() {
            try {
                Calendar calendar = Calendar.getInstance();
                calendar.add(Calendar.SECOND, 10);
                lock.lock();
                System.out.println("wait begin timer=" + System.currentTimeMillis());
                condition.awaitUntil(calendar.getTime());//到达等待时间可唤醒自己
                System.out.println("wait end   timer=" + System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    
        public void notifyMethod() {
            try {
                Calendar calendar = Calendar.getInstance();
                calendar.add(Calendar.SECOND, 10);
                lock.lock();
                System.out.println("notify begin timer=" + System.currentTimeMillis());
                condition.signalAll();//线程在等待时间到达前，可以被其他线程唤醒
                System.out.println("notify end   timer=" + System.currentTimeMillis());
            } finally {
                lock.unlock();
            }
        }
    }
    
    public class test {
        public static void main(String[] args) {
            try {
                Service service = new Service();
                new Thread(()->{
                    service.waitMethod();
                }).start();
                Thread.sleep(2000);
                new Thread(()->{
                    service.notifyMethod();
                }).start();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

Condition实现顺序打印:

public class test{
        volatile private static int nextPrintWho = 1;
        private static ReentrantLock lock = new ReentrantLock();
        //每个线程个一个condition
        final private static Condition conditionA = lock.newCondition();
        final private static Condition conditionB = lock.newCondition();
        final private static Condition conditionC = lock.newCondition();
    
        public static void main(String[] args) {
            Thread a = new Thread() {
                @Override
                public void run() {
                    try {
                        lock.lock();
                        while (nextPrintWho != 1) {
                            conditionA.await();
                        }
    
                        for (int i = 0; i < 3; i++) {
                            System.out.println("ThreadA " + (i + 1));
                        }
                        nextPrintWho = 2;
                        conditionB.signalAll();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lock.unlock();
                    }
                }
            };
    
            Thread b = new Thread() {
                @Override
                public void run() {
                    try {
                        lock.lock();
                        while (nextPrintWho != 2) {
                            conditionB.await();
                        }
                        for (int i = 0; i < 3; i++) {
                            System.out.println("ThreadB " + (i + 1));
                        }
                        nextPrintWho = 3;
                        conditionC.signalAll();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lock.unlock();
                    }
                }
            };
    
            Thread c = new Thread() {
                @Override
                public void run() {
                    try {
                        lock.lock();
                        while (nextPrintWho != 3) {
                            conditionC.await();
                        }
                        for (int i = 0; i < 3; i++) {
                            System.out.println("ThreadC " + (i + 1));
                        }
                        nextPrintWho = 1;
                        conditionA.signalAll();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lock.unlock();
                    }
                }
            };
    
            Thread[] aArray = new Thread[5];
            Thread[] bArray = new Thread[5];
            Thread[] cArray = new Thread[5];
    
            for (int i = 0; i < 5; i++) {
                aArray[i] = new Thread(a);
                bArray[i] = new Thread(b);
                cArray[i] = new Thread(c);
    
                aArray[i].start();
                bArray[i].start();
                cArray[i].start();
            }
    
        }
    }