Java并发编程学习（四）—— Lock

最新推荐文章于 2022-05-23 11:21:46 发布
最新推荐文章于 2022-05-23 11:21:46 发布
阅读量243 收藏
点赞数
分类专栏： 读书笔记 文章标签： java 并发 编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/amurocrash/article/details/78779594
版权

一、ReentrantLock

1、Reentrant其实是ReEntrant，可重入的意思。先来个标准例子：

package com.amuro.studythread.chapter4_lock;

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample
{
    public static void main(String[] args)
    {
        A a = new A();

        for(int i = 0; i < 5; i ++)
        {
            Thread t = new Thread(new Runnable()
            {

                @Override
                public void run()
                {
                    a.a();
                }

            });
            t.setName("t" + (i + 1));
            t.start();
        }
    }

    static class A
    {
        ReentrantLock lock = new ReentrantLock();

        void a()
        {
            lock.lock();

            String tName = Thread.currentThread().getName();
            for(int i = 0; i < 10; i++)
            {
                System.out.println(tName + " : " + (i + 1));
            }

            b();

            lock.unlock();
        }

        void b()
        {
            lock.lock();

            System.out.println("tName b");

            lock.unlock();
        }
    }
}

程序输出：
t1 : 1
t1 : 2
t1 : 3
t1 : 4
t1 : 5
t1 : 6
t1 : 7
t1 : 8
t1 : 9
t1 : 10
t1 b
t2 : 1
t2 : 2
t2 : 3
t2 : 4
t2 : 5
t2 : 6
t2 : 7
t2 : 8
t2 : 9
t2 : 10
t2 b
t3 : 1
t3 : 2
t3 : 3
t3 : 4
t3 : 5
t3 : 6
t3 : 7
t3 : 8
t3 : 9
t3 : 10
t3 b
t4 : 1
t4 : 2
t4 : 3
t4 : 4
t4 : 5
t4 : 6
t4 : 7
t4 : 8
t4 : 9
t4 : 10
t4 b
t5 : 1
t5 : 2
t5 : 3
t5 : 4
t5 : 5
t5 : 6
t5 : 7
t5 : 8
t5 : 9
t5 : 10
t5 b
可以见这种情况下，lock的作用和synchronized的几乎一样，是一把可重入的锁。

2、condition/signal == wait/notify

package com.amuro.studythread.chapter4_lock;

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

public class ConditionExample
{
    public static void main(String[] args) throws Exception
    {
        final Service service = new Service();

        Thread t = new Thread(new Runnable()
        {

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

        Thread.sleep(3000);
        service.signal();
    }

    static class Service
    {
        ReentrantLock lock = new ReentrantLock();
        Condition condition = lock.newCondition();

        void await()
        {
            try
            {
                lock.lock();
                System.out.println("await begin");
                condition.await();
                System.out.println("await end");
            }
            catch (Exception e) 
            {
            }
            finally
            {
                lock.unlock();
            }
        }

        void signal()
        {
            lock.lock();
            System.out.println("signal");
            condition.signal();
            lock.unlock();

        }
    }
}

程序输出：
await begin
signal
await end

package com.amuro.studythread.chapter4_lock;

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

public class ConditionExample
{
    public static void main(String[] args) throws Exception
    {
        final Service service = new Service();

        Thread t1 = new Thread(new Runnable()
        {

            @Override
            public void run()
            {
                service.await1();

            }
        });
        t1.start();

        Thread t2 = new Thread(new Runnable()
        {

            @Override
            public void run()
            {
                service.await2();
            }
        });
        t2.start();

        Thread.sleep(3000);
        service.signal();
    }

    static class Service
    {
        ReentrantLock lock = new ReentrantLock();
        Condition condition = lock.newCondition();

        void await1()
        {
            try
            {
                lock.lock();
                System.out.println("await1 begin");
                condition.await();
                System.out.println("await1 end");
            }
            catch (Exception e) 
            {
            }
            finally
            {
                lock.unlock();
            }
        }

        void await2()
        {
            try
            {
                lock.lock();
                System.out.println("await2 begin");
                condition.await();
                System.out.println("await2 end");
            }
            catch (Exception e) 
            {
            }
            finally
            {
                lock.unlock();
            }
        }

        void signal()
        {
            lock.lock();
            System.out.println("signal");
            condition.signalAll();
            lock.unlock();

        }
    }
}

程序输出：
await1 begin
await2 begin
signal
await1 end
await2 end

3、实现生产消费者模式

package com.amuro.studythread.chapter4_lock;

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

public class SinglePC
{
    public static void main(String[] args)
    {
        P p = new P();
        C c = new C();

        new Thread(new Runnable()
        {

            @Override
            public void run()
            {
                while(true)
                {
                    p.set();
                }
            }
        }).start();

        new Thread(new Runnable()
        {

            @Override
            public void run()
            {
                while(true)
                {
                    c.get();
                }
            }
        }).start();


    }

    static String value = "";
    static ReentrantLock lock = new ReentrantLock();
    static Condition condition = lock.newCondition();

    static class P
    {


        void set()
        {
            try
            {
                lock.lock();

                while(!"".equals(value))
                {
                    condition.await();
                }

                System.out.println("empty");
                value = "Double X";
                Thread.sleep(2000);
                condition.signal();

            }
            catch (Exception e) 
            {

            }
            finally
            {
                lock.unlock();
            }
        }
    }

    static class C
    {
        void get()
        {
            try
            {
                lock.lock();

                while("".equals(value))
                {
                    condition.await();
                }

                System.out.println(value);
                value = "";
                Thread.sleep(2000);
                condition.signal();

            }
            catch (Exception e) 
            {

            }
            finally
            {
                lock.unlock();
            }
        }
    }
}

4、公平锁与非公平锁
公平锁：线程获取锁的顺序遵循先到先得；
非公平锁：非先到先得，可能导致某些线程一直拿不到锁。
创建方法：

ReentrantLock lock = new ReentrantLock(true);//fair
ReentrantLock lock = new ReentrantLock(false);//unfair

5、lock的常用方法
1）int getHoldCount
当前线程保持此锁定的个数，也就是调用lock方法的次数。

2）int getQueueLength()
等待获取此lock的线程数，比如5个线程争夺一个lock，当1个线程获得lock后执行了sleep方法，此时调用getQueueLength方法返回的结果为4。

3）int getWaitQueueLength()
5个线程，每个线程都执行了同一个condition的await方法，则调用此方法返回5。

4）boolean hasQueueThread(thread)和bolean hasQueueThreads()
查询指定线程是否在等待获取锁；
查询是否有线程在等待获取锁。

5）boolean hasWaiters(condition)
查询是否有线程在用当前condition进行等待。

6）boolean isFair()
查询是否公平锁。

7）boolean isHeldByCurrentThread()和boolean isLocked()
查询当前线程是否获得了锁。
查询是否有线程了获得了锁。

8）void lockInterruptibly()
不太好解释，先看代码：

package com.amuro.studythread.chapter4_lock;

import java.util.concurrent.locks.ReentrantLock;

public class LockInterruptibly
{
    public static void main(String[] args) throws Exception
    {
        final Service s = new Service();
        Thread tA = new Thread(new Runnable()
        {

            @Override
            public void run()
            {
                s.invoke();
            }
        });
        tA.start();
        Thread.sleep(500);

        Thread tB = new Thread(new Runnable()
        {

            @Override
            public void run()
            {
                s.invoke();
            }
        });
        tB.start();

        tB.interrupt();
        System.out.println("main end");
    }

    static class Service
    {
        private ReentrantLock lock;

        public Service()
        {
            lock = new ReentrantLock();
        }

        void invoke()
        {
            try
            {
                lock.lock();
//              lock.lockInterruptibly();
                System.out.println(Thread.currentThread().getName() + " begin");

                for(int i = 0; i < Integer.MAX_VALUE / 10; i++)
                {
                    String str = new String();
                    Math.random();
                }   

                System.out.println(Thread.currentThread().getName() + " end");
            }
            catch (Exception e) 
            {
                System.out.println(Thread.currentThread().getName() + " goes into exception " + e.getMessage());
            }
            finally
            {
                if(lock.isHeldByCurrentThread())
                {
                    lock.unlock();
                }
            }
        }
    }
}

当使用lock.lock()时，打印结果为：
Thread-0 begin
main end
Thread-0 end
Thread-1 begin
Thread-1 end
当使用lock.lockInterruptibly时，打印结果为：
Thread-0 begin
main end
Thread-1 goes into exception null
Thread-0 end

由此可见，lockInterruptibly方法的意义是：如果线程未被中断（调用interrupt方法）时，可以正常获取锁，如果已经被中断则抛出异常。

9）boolean tryLock()
这个方法最大的好处就是发现拿不到锁的时候，可以进行其他处理。方法会直接返回false。

10）void awaitUninterruptibly()
正常情况下，在condition.await的时候调用线程的interrupt方法会导致抛出异常，但是如果使用awaitUninterruptibly方法，就不会抛出异常，程序会继续等待signal。

11）void awaitUtil(Date)

package com.amuro.studythread;

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

public class Test
{
    public static void main(String[] args) throws Exception
    {
        final Test t = new Test();
        Thread th = new Thread(new Runnable()
        {

            @Override
            public void run()
            {
                t.invoke();
            }
        });
        th.start();

        Thread.sleep(1000);
        t.signal();
    }

    ReentrantLock lock;
    Condition condition;

    public Test()
    {
        lock = new ReentrantLock();
        condition = lock.newCondition();
    }

    void invoke()
    {
        try
        {
            Calendar c = Calendar.getInstance();
            c.add(Calendar.SECOND, 3);
            lock.lock();
            System.out.println("begin");
            condition.awaitUntil(c.getTime());
            System.out.println("end");
        } 
        catch(Exception e)
        {
            System.out.println("exception: " + e.getMessage());
        }
        finally
        {
            lock.unlock();
        }
    }

    void signal()
    {
        try
        {
            lock.lock();
            condition.signal();
        }
        finally
        {
            lock.unlock();
        }
    }
}

线程会一直等待到传入的时间，但是可以被signal提前打断。

6、condition实现线程的顺序执行

package com.amuro.studythread.chapter4_lock;

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

public class SequenceThreadInvoke
{
    static int go = 1;

    public static void main(String[] args)
    {
        final ReentrantLock lock = new ReentrantLock();
        final Condition condition = lock.newCondition();
        int length = 5;

        for(int i = 0; i < length; i++)
        {
            MyThread t = new MyThread(i + 1)
            {
                @Override
                public void run()
                {
                    while(true)
                    {
                        try
                        {
                            lock.lock();
                            while(go != getI())
                            {
                                condition.await();
                            }

                            System.out.println(getI());
                            if(go == length)
                            {
                                go = 1;
                            }
                            else
                            {
                                go++;
                            }
                            Thread.sleep(1000);
                            condition.signalAll();
                        }
                        catch (Exception e) 
                        {

                        }
                        finally
                        {
                            lock.unlock();
                        }
                    }
                }
            };
            t.start();
        }

    }

    static class MyThread extends Thread
    {
        int i;

        public MyThread(int i)
        {
            super();
            this.i = i;
        }

        public int getI()
        {
            return i;
        }
    }
}

二、ReentrantReadWriteLock

1、概念
ReentrantLock和synchronized都有天然的缺陷就是同一时间只能有一个线程获得锁，虽然保证了线程安全，但是效率极其低下。所以java又提供了读写锁，其中读锁是共享锁，在没有线程进行写入操作时，多个线程可以同时获得读锁；但是同一时刻只允许一个线程进行写操作。

2、读读共享，写写互斥

package com.amuro.studythread.chapter4_lock;

import java.util.Date;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class WRLockExample1
{
    public static void main(String[] args) throws Exception
    {
        final File file = new File();
        for(int i = 0; i < 10; i++)
        {
            new Thread(new Runnable()
            {

                @Override
                public void run()
                {
                    file.read();
                }
            }).start();
        }

        Thread.sleep(2000);

        for(int i = 0; i < 10; i++)
        {
            new Thread(new Runnable()
            {

                @Override
                public void run()
                {
                    file.write();
                }
            }).start();
        }
    }

    static class File
    {
        ReentrantReadWriteLock wrLock;

        public File()
        {
            wrLock = new ReentrantReadWriteLock();
        }

        void read()
        {
            try
            {
                wrLock.readLock().lock();
                System.out.println(
                        Thread.currentThread().getName() + 
                        " get read lock on " + 
                        new Date(System.currentTimeMillis()));
                Thread.sleep(1000);
            }
            catch (Exception e) 
            {

            }
            finally
            {
                wrLock.readLock().unlock();
            }
        }

        void write()
        {
            try
            {
                wrLock.writeLock().lock();
                System.out.println(
                        Thread.currentThread().getName() + 
                        " get write lock on " + 
                        new Date(System.currentTimeMillis()));
                Thread.sleep(1000);

            }
            catch(Exception e)
            {

            }
            finally
            {
                wrLock.writeLock().unlock();
            }
        }
    }

}

程序输出：
Thread-7 get read lock on Wed Jan 03 10:47:52 CST 2018
Thread-9 get read lock on Wed Jan 03 10:47:52 CST 2018
Thread-3 get read lock on Wed Jan 03 10:47:52 CST 2018
Thread-0 get read lock on Wed Jan 03 10:47:52 CST 2018
Thread-2 get read lock on Wed Jan 03 10:47:52 CST 2018
Thread-1 get read lock on Wed Jan 03 10:47:52 CST 2018
Thread-8 get read lock on Wed Jan 03 10:47:52 CST 2018
Thread-4 get read lock on Wed Jan 03 10:47:52 CST 2018
Thread-5 get read lock on Wed Jan 03 10:47:52 CST 2018
Thread-6 get read lock on Wed Jan 03 10:47:52 CST 2018
Thread-10 get write lock on Wed Jan 03 10:47:54 CST 2018
Thread-12 get write lock on Wed Jan 03 10:47:55 CST 2018
Thread-11 get write lock on Wed Jan 03 10:47:56 CST 2018
Thread-13 get write lock on Wed Jan 03 10:47:57 CST 2018
Thread-14 get write lock on Wed Jan 03 10:47:58 CST 2018
Thread-15 get write lock on Wed Jan 03 10:47:59 CST 2018
Thread-16 get write lock on Wed Jan 03 10:48:00 CST 2018
Thread-17 get write lock on Wed Jan 03 10:48:01 CST 2018
Thread-18 get write lock on Wed Jan 03 10:48:02 CST 2018
Thread-19 get write lock on Wed Jan 03 10:48:03 CST 2018
这个很好理解，不多说了；

3、读写互斥，写读互斥

package com.amuro.studythread.chapter4_lock;

import java.util.Date;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class WRLockExample2
{
    public static void main(String[] args) throws Exception
    {
        final File file = new File();
        new Thread(new Runnable()
        {

            @Override
            public void run()
            {
                file.read();

            }
        }).start();

        new Thread(new Runnable()
        {

            @Override
            public void run()
            {
                file.write();
            }
        }).start();
    }

    static class File
    {
        ReentrantReadWriteLock wrLock;

        public File()
        {
            wrLock = new ReentrantReadWriteLock();
        }

        void read()
        {
            try
            {
                wrLock.readLock().lock();
                System.out.println(
                        Thread.currentThread().getName() + 
                        " get read lock on " + 
                        new Date(System.currentTimeMillis()));
                Thread.sleep(5000);
            }
            catch (Exception e) 
            {

            }
            finally
            {
                wrLock.readLock().unlock();
            }
        }

        void write()
        {
            try
            {
                wrLock.writeLock().lock();
                System.out.println(
                        Thread.currentThread().getName() + 
                        " get write lock on " + 
                        new Date(System.currentTimeMillis()));
                Thread.sleep(1000);

            }
            catch(Exception e)
            {

            }
            finally
            {
                wrLock.writeLock().unlock();
            }
        }
    }

}

程序输出：
Thread-0 get read lock on Wed Jan 03 11:05:47 CST 2018
Thread-1 get write lock on Wed Jan 03 11:05:52 CST 2018
可见当一个读写锁之间是互斥的，在读锁或者写锁没有unlock时，无法获得另一种锁。

amurocrash
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java8 ReentrantLock 源码解析
菜鸟进阶之路
04-03 840
目录 一、AbstractQueuedSynchronizer 1、定义 2、Unsafe objectFieldOffset和staticFieldOffset 3、Node 二、ReentrantLock 1、acquireQueued 2、lock 3、lockInterruptibly 4、tryLock 5、unlock 6、其他方法实现总结 R...
Java并发编程深入学习——Lock锁
BridgeGeorge
09-27 459
Lock锁介绍在Java 5.0之前，在协调对共享对象的访问时可以使用的机制只有synchronized和volatile。Java 5.0 增加了一种新的机制：ReentrantLock.它并不是一种替代内置加锁的方法，而是当内置加锁机制不适用时，作为一种可选择的高级功能。Lock接口Lock接口位于java.util.concurrent.locks包中，它定义了一组抽象的加锁操作。public
Java多线程问题--方法isFair()、isHeldByCurrentThread()和isLocked()的用法和区别
樊先知樊先知的博客
01-24 1万+
本文内容部分引自《Java多线程编程核心技术》，感谢作者！！！ 代码地址：https://github.com/xianzhixianzhixian/thread.git 方法isFair()、isHeldByCurrentThread()和isLocked()的用法和区别 1、lock.isFair()方法用来判断lock锁是公平锁还是非公平锁。公平锁是指，线程获得锁的顺序是按其等待锁...
多线程编程第四章Lock的使用
孤竹彧的根据地
03-05 1278
使用ReentrantLock lock.lock();//此方法相当于上锁 lock.unlock();//此方法相当于释放锁 Condition condition = lock.newCondition(); condition.await();//相当于wait() condition.signal();//相当于nontify condition.signalAll();//相当于no...
java并发编程系列之Lock的使用
Fighter168的专栏
02-09 401
Jdk1.5中，在Java.util.concurrent.locks包下，有一组实现线程同步的接口和类，说到线程的同步，很多立马就会想到synchronized关键字，这是java内置的关键字，用来处理线程同步的，但这个关键字有很多的缺陷，使用起来也不是很方便和直观，所以就出现了Lock，下面，我们就来对比着讲解Lock。 synchronized关键字： 该关键字在使用的过程中会有
java并发编程 之 Lock（锁的妙用）
wuseyukui的专栏
04-06 1459
Java 5中提供了另一种实现线程同步或互斥的机制，即使用Lock。Lock比传统线程模型中的synchronized方式更加面向对象。 读写锁：分为读锁和写锁，多个读锁不互斥，读锁与写锁互斥，写锁与写锁互斥，这是由JVM控制的，我们只需要上好相应的锁即可。如果代码只读数据，可以很多人同时读，但不能同时写，那就上读锁；如果代码修改数据，只能有一个人在写，并不能同时读取，那就上写销锁。总之，读的时候
Java并发编程——ReentrantLock
wait2023的博客
05-23 163
1 类图结构 ReentrantLock是JUC包下的一个独占锁，类图结构如下： 可以看到，其实现了Lock接口，并且底层是通过AQS抽象同步队列来实现的，我们直到AQS中有一个state状态变量，在ReentrantLock，state = 0时表示该锁还未被任何线程持有，大于1时则表示该锁已经被线程所持有，并且表示了该锁的重入次数。其中Sync是该类的一个内部类，NonfairSync和FaiSync分别对应获取锁的非公平与公平策略。对于这个锁，我们常用的就是lock与unlock方法，再就是C
Java并发编程图册Java并发编程图册
最新发布
03-29
首先，我们需要理解Java并发编程的基础——线程。在Java中，通过`Thread`类或者实现`Runnable`接口来创建线程。线程是程序执行的最小单位，允许多个任务在同一时间内执行。通过线程，我们可以实现并行处理，提升程序...
Java多线程基础——Lock类
08-31
在Java 1.5及之后的版本中引入，Lock类的主要目的是提高并发性能和可读性。以下是关于Lock类及其相关功能的详细介绍： 1. **Lock类**： Lock接口由`java.util.concurrent.locks`包提供，它的实现类包括`...
java 并发编程实践
05-19
本篇文章将深入探讨Java并发编程的相关知识点，主要基于提供的两个文件——"Java并发编程实战（中文版）.pdf"和"Java Concurrency in Practice.pdf"。 1. **线程与并发** - **线程基础**：Java中的线程是并发执行...
《java并发编程艺术》
04-19
《Java并发编程艺术》这本书是Java开发者深入理解多线程编程的重要参考资料。它详细阐述了Java平台上的并发编程原理和实践技巧，旨在帮助开发者解决在多线程环境下遇到的各种复杂问题。 1. **并发基础** - **线程...
Java并发学习笔记（二）——Synchronized关键字与ReetrantLock同步锁
12-20
【Java并发学习笔记（二）——Synchronized关键字与ReentrantLock同步锁】 在Java多线程编程中，确保线程安全是非常重要的。Synchronized关键字和ReentrantLock是两种常见的同步机制，它们都用于保证线程的原子性、...
Java并发编程：Lock
帅性而为1号的博客
04-06 1359
synchronized是java中的一个关键字，也就是说是Java语言内置的特性。那么为什么会出现Lock呢？　　如果一个代码块被synchronized修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁会有三种情况：　　1）获取锁的线程执行完了该代码块，然后线程释放对锁的占有；　　2）线程执行发生异常，此时JVM会让线程...
Java多线程Lock对象常用方法(3)
Lucy_Leezhi
02-27 2164
下面练习一下如下几个方法： isHeldByCurrentThread():查询当前线程是否保持此锁定 isFair():判断Lock是否为公平锁 isLocked():查询lock 是否被任意线程所持有。package com.lenovo.plm.dms.p23;import java.util.concurrent.locks.ReentrantLock;public class Ser
isrun java用法_Java多线程问题--方法isFair()、isHeldByCurrentThread()和isLocked()的用法和区别...
weixin_42134234的博客
02-17 648
本文内容部分引自《Java多线程编程核心技术》，感谢作者！！！代码地址：https://github.com/xianzhixianzhixian/thread.git方法isFair()、isHeldByCurrentThread()和isLocked()的用法和区别1、lock.isFair()方法用来判断lock锁是公平锁还是非公平锁。公平锁是指，线程获得锁的顺序是按其等待锁的先后顺序来的，...
Android开发艺术探索读书笔记（二）
热门推荐
amurocrash的专栏
09-25 1万+
首先感谢大家支持，昨天第一篇写出来之后反响很好，主席本人也非常赞赏（捂脸～），再接再厉，推出第二篇。这篇的主要内容是对两章View的内容进行总结。不得不说，自定义View是很多开发者的痛点，一方面我们很羡慕大神们做出骚气又酷炫的界面，另一方面我们又苦于网上的资料过于凌乱和纷杂导致很多时候越学越晕。尤其工科，想要深入掌握某种知识，体系化是非常重要的，就像我们必须先学四则运算，才能进阶到更复杂的开方乘方
Android开发艺术探索读书笔记（三）
amurocrash的专栏
10-06 1万+
日以继夜近两个星期，终于完成这篇了，之所以自己这么看重，是因为这篇应该是读书笔记里最重要的一篇了，这篇能吃透的话，基本安卓app层玩的机制都能理解的很清楚了，所以我也倾注了全部的心血来写这篇，希望跟大家一起分享。 简单先说下：这里将第九章（四大组件的工作过程），第十章（Android的消息机制）放在第八章（理解Window和WindowManager）前面的原因是：学习理解Window的知识最好
Android开发艺术探索读书笔记（一）
amurocrash的专栏
09-24 9442
首先向各位严重推荐主席这本书《Android开发艺术探索》。     再感谢主席邀请写这篇读书笔记 ＋ 书评。书已经完整的翻完一遍了，但是还没有细致的品读并run代码，最近有时间正好系统的把整本书从内容到代码都梳理一遍，一方面方便自己总结，一方面也为主席宣传，如果你还在犹豫要不要入手这本书的时候，希望看完我的笔记，能激发你购买的动力。OK，言归正传，下面先简单写几句书评，本人技术有限，只是从自身
《Java并发编程实战指南》：深度探索多线程与并发安全
《Java Concurrency in Practice》是由Brian Göetz、Tim Peierls、Joshua Bloch、Joseph Bowbeer、David Holmes和Doug Lea合著的一本权威指南，专为Java程序员设计，旨在深入解析Java中的并发编程。本书在实践中...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值