Java多线程读书笔记（四）

最新推荐文章于 2024-10-06 20:16:20 发布

lengarry

最新推荐文章于 2024-10-06 20:16:20 发布

阅读量291

点赞数

分类专栏： java 文章标签： java 读书笔记多线程线程

本文链接：https://blog.csdn.net/lengarry/article/details/78633042

版权

java 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

Lock的使用

ReentrantLock的使用

Java多线程中，除了synchronized关键字能实现线程之间的同步互斥，ReentrantLock 也能实现类似的效果，并在扩展功能上也更为强大，比如嗅探锁定，多路分支通知。嗅探锁定是啥本篇笔记不涉及，不知道是啥。

1.如何使用reentrantLock实现同步？

MyService.java:获得锁定

 import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.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();
        }

    }

MyThread.java:线程类

 import service.MyService;

    public class MyThread extends Thread {

        private MyService service;

        public MyThread(MyService service) {
            super();
            this.service = service;
        }

        @Override
        public void run() {
            service.testMethod();
        }
    }

Run.java:测试类

 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();   
        }  
    }

调用ReentrantLock 对象的lock()方法获得锁，调用unlock()方法释放锁，同样获得同步的效果。调用了lock.lock()方法的线程持有了“对象监视器”，其他线程只能继续等待锁被释放，继续争抢。

2.使用Condition实现等待/通知？

使用synchronized关键字和wait/notify(notifyAll)可以实现等待/通知模式。ReentrantLock和Condition结合可以实现同样的功能。并且具有更好的灵活性。比如实现“多路通知功能”。

3.什么是“多路通知功能”，有啥好处？

在一个Lock对象里面可以创建多个Condition（即对象监视器）实例，线程对象可以注册在指定的condition对象中，从而可以有选择的进行线程通知，调度线程上更为灵活。

4.和notify，notifyAll做个比较？

notify,notifyAll实现线程的通知时，有虚拟机JVM随机选择线程被通知，这个过程具有“随机性”。但是ReentrantLock对象和Condition对象结合使用可实现“有选择的通知”。

5.和synchronized比较？

synchronized相当于整个Lock对象只有一个Condition对象，所有的线程都注册在这个Condition上，线程开始notifyAll时，所有的线程都会被唤醒，效率较低。

6.如何代码实现Condition的等待/通知？

MyService.java:

 public class MyService {
        //创建锁
        private Lock lock = new ReentrantLock();
        //创建Condition对象
        public Condition condition = lock.newCondition();

        public void await() {
            try {
                lock.lock();//上锁
                System.out.println(" await时间为" + System.currentTimeMillis());
                condition.await();//当前线程wait()
            } 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();//解锁
            }
        }
    }

ThreadA.java:

  public class ThreadA extends Thread {

        private MyService service;

        public ThreadA(MyService service) {
            super();
            this.service = service;
        }

        @Override
        public void run() {
            service.await();
        }
    }

Run.java:

 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();

        }    
    }

7.如何使用多个Condition对象实现通知部分线程？

使用同一个Lock对象同时创建多个Condition对象。conditionA.await()和conditionA.signalAll()对应，conditionB.await()和conditionB.signalAll()对应。

8.“公平锁”和“非公平锁”？

公平锁表示线程获得锁的顺序是按照线程加锁的顺序来分配的。即“先来先得”，FIFO。
非公平锁就是一种锁的抢占机制，随机获取锁。

9.lock的各种方法盘点

int getHoldCount():查询当前线程保持此锁定的个数，也就是lock()方法的调用次数。
int getQueueLength():返回正等待获取此锁定的线程估计数。启动了五个线程，只有一个线程在执行，那么就有4个线程在等待，值为4。
int getWaitQueueLength(Condition condition):返回等待与此锁相关的给定条件Condition的线程估计数。比如，有10个线程处于该condition.await()下的阻塞状态，那么就是说，返回值为10.
boolean hasQueuedThread(Thread thread):查询指定的线程是否正在等待获取此锁定。
boolean hasQueuedThreads():查询是否有线程正在等待获取此锁定
boolean hasWaiters(Condition condition):查询是否有线程在等待与此锁定有关的condition的条件。
boolean isFair():判断是不是公平锁。
boolean isHeldByCurrentThread():查询当前线程是否保持此锁定。
boolean isLocked():查询此锁定是否有任意线程保持。
void lockInterruptibly():如果当前线程未被中断，则尝试获取该锁定，和lock()一样，如果已经被中断则出现异常。要是锁定完了再interupt线程，不会报异常的，会正常执行下去。
boolean tryLock():仅在调用时锁定未被另一个线程保持的情况下，才获取该锁。
boolean tryLock(long timeout, TimeUnit unit) :如果锁定在给定时间内没有被另一个线程保持，且当前线程未被中断，则获取该锁定。这俩tryLock()真是有礼貌的锁呢，不争不抢，和外面那群妖艳jian锁不一样，这么清纯不做作。

10.condition的方法锦集

awaitUninterruptibly():线程处于阻塞等待时不会被interrupt()勾搭到抛异常。
awaitUntil(Calendar.getInstance.add(Calendar.SECOND,10).getTime()):10秒之后，如果没人喊醒该线程，它就自己爬起来，重新参与锁竞争。
使用Condition对象可以对线程执行的任务进行业务排序规划，这里就不讲了。

ReentrantReadWriteLock的使用

1.ReentrantLock和ReentrantReadWriteLock的不同之处？

ReentrantLock.lock()具有“完全互斥排他”的效果，同一时间只有一个线程执行ReentrantLock.lock()后的内容。
ReentrantReadWriteLock读写锁，用来提升运行效率。读写锁有两个锁。一个是读操作相关的锁，也称为共享锁；另一个是写操作相关的锁，也叫排他锁。

多个读锁之间不互斥，读锁和写锁互斥，多个写锁互斥。

定时器Timer

1.Timer设置任务计划，TimerTask封装具体业务。

看看Timer的构造方法,可以发现，启动一个定时器就是启动了一个线程：

 public Timer(String name) {
        thread.setName(name);
        thread.start();
    }

另外，线程有非守护线程和守护线程之分，创建普通定时器：

   Timer timer = new Timer();

创建守护线程：

 Timer timer = new Timer(true);

创建定时任务的简单例子：

    public class Run1 {

        private static Timer timer = new Timer();
        //内部任务，继承TimerTask类
        static public class MyTask extends TimerTask {
            @Override
            public void run() {
                System.out.println("运行了，时间为：" + new Date());
            }
        }

        public static void main(String[] args) {
            try {
                MyTask task = new MyTask();
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                String dateString = "2017-11-14 14:24:20";

                Date dateRef = sdf.parse(dateString);
                System.out.println("字符串事件为：" + dateRef.toLocaleString() + " 当前时间为："
                        + new Date().toLocaleString());
                timer.schedule(task, dateRef);//启动定时器
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
    }

方法锦集：

schedule(TimerTask task, Date time):在指定的日期执行一次某一任务。当指定的日期晚于当前时间，正常执行；如果指定时间早于当前时间，立即执行。使用一个定时器启动多个定时任务时，TimerTask会以队列的方式一个一个被顺序执行。既然如此，很有可能有些任务的执行时间比较长，导致下一个任务无法按时执行，这时候，下一个任务就会在这次任务结束之后立即执行。
schedule(TimerTask task,Date firstTime,long period):指按照指定的间隔周期性地无限循环地执行某一任务。当初次计划时间晚于当前时间时，正常执行；当初次计划时间早于当前时间会立即执行。
TimerTask类的cancel()方法：作用是将自身从任务队列中清除出去，其他任务不受影响。
Timer类的cancel()方法：将任务队列中的全部任务清空。
schedule(TimerTask task,long delay):以当前的时间为参考时间，在此时间的基础之上，延迟指定的毫秒数。任务执行一次。
schedule(TimerTask task,long delay,long period):以当前的时间为参考时间，在此时间的基础之上，延迟指定的毫秒数,执行第一次任务，之后以peroid毫秒数时间间隔无限循环下去。
scheduleAtFixedRate(TimerTask task,Date firstTime,long period):第一次执行时间firstTimer，之后以period毫秒间隔无线循环下去。

2.scheduleAtFixedRate和schedule的不同之处？

两种方法都会按照顺序执行任务。所以不用考虑非线程安全的问题。
两者的区别在于不延时的情况。

schedule(TimerTask task,Date firstTime,long period)：如果任务不延时，下一次任务开始时间就按照上一次任务的 “开始” 时间加上period毫秒数计算。如果上一次任务延时，导致上一次任务结束时间晚于下一次任务的开始时间，那么下一次任务就会在上一次任务执行完的时候立即执行。此外，该方法 不具有追赶执行性 ，晚于初次计划时间启动的话，晚于当前时间的计划任务直接取消！
scheduleAtFixedRate(TimerTask task,Date firstTime,long period)：如果任务不延时，下一次任务开始时间就按照上一次任务的“结束”时间加上period毫秒数计算。如果上一次任务延时，导致上一次任务结束时间晚于下一次任务的开始时间，那么下一次任务就会在上一次任务执行完的时候立即执行。此外，该方法 具有追赶执行性 。

分享今天看见的美丽的话：

你背单词时，阿拉斯加的鳕鱼正跃出水面，你上晚自习时，海鸥盘旋在海天之间，你算数学时，极光布满斑斓的夜空。但是少年你别着急，当你为了未来踏踏实实努力的时候，那些你觉得永远不会看到的景色，一辈子不会遇到的人，正一步步向你走来。

高中时候想法很浪漫，要去雅典看希腊柱，骑个自行车自由散漫地逛着。不过大学毕业后这个愿望依旧没实现，常后悔高中大学没有更努力，但是有什么用呢，这都是既定事实，未必比现在好很多。现在也要努力啊。“人生”在辽阔处，心要大，眼光要放得远。

哈哈，正在写着博客（(┬＿┬)，抓包了吧？），组长发山核桃了，超nice。不过我还是很怕他，唉。感觉自己像个疯子。

PS：本篇内容属于读书笔记，非常感谢高洪岩老师的《Java多线程编程的核心技术》。这本书非常实用，易懂。如果涉及任何侵权行为，请尽快告诉我。