《Java并发编程之美》学习笔记及补充

文章目录

  • 前言
  • 第一部分 Java并发编程基础篇
    • 第1章 并发编程线程基础
      • 1.1 什么是线程
        • JVM内存区域(运行时数据区域)
      • 1.2 线程创建与运行
      • 1.3 线程通知与等待
        • 为什么wait/notify/notifyAll必须要放在synchronized中
        • 线程的六种状态
      • 1.4 等待线程执行终止的join方法
      • 1.5 让线程睡眠的sleep方法
      • 1.6 让出CPU执行权的yield方法
      • 1.7 线程中断
      • 1.8 理解线程上下文切换
      • 1.9 线程死锁
      • 1.11 ThreadLocal
        • 强引用、软引用、弱引用、虚引用
    • 第2章 并发编程的其他基础知识
      • 2.9 Unsafe类
        • Unsafe为什么不安全
        • Unsafe类与反射去区别
  • 第二部分 Java并发编程高级篇
    • 第3章 Java并发包中ThreadLocalRandom类原理剖析
        • ThreadLocalRandom 为什么非要使用 Unsafe 来修改 Thread 对象内的随机种子?
    • 第4章 Java并发包中原子操作类原理剖析
      • 4.1 原子变量操作类
      • 4.2 JDK 8新增的原子操作类LongAdder
    • 第6章 Java并发包中锁原理剖析
      • 6.1 LockSupport工具类
      • 6.2 抽象同步队列aqs概述
        • 6.2.1 AQS——锁的底层支持
        • 6.2.2 AQS——条件变量的支持
        • 6.2.3 基于AQS实现自定义同步器
      • 6.3 ReentrantLock的原理
        • 6.3.1 类图结构
        • 6.3.2 获取锁
        • 6.3.3 释放锁
      • 6.4 读写锁ReentrantReadWriteLock原理
        • 6.4.1 类图结构
        • 6.4.2 写锁的获取与释放
        • 6.4.3 读锁的获取与释放
        • 6.4.4 案例介绍
      • 6.5 JDK 8中新增的StampedLock锁探究
    • 第7章 Java并发包中并发队列原理剖析
      • 7.1 ConcurrentLinkedQueue原理探究
      • 7.2 LinkedBlockingQueue原理探究
      • 7.3 ArrayBlockingQueue原理探究
    • 第8章 Java并发包中线程池ThreadPoolExecutor原理探究
      • 8.1 介绍
      • 8.2 类图介绍
      • 8.3 源码分析
        • 合理配置线程池
      • 8.4 总结
    • 第9章 Java并发包中ScheduledThreadPoolExecutor原理探究
    • 第10章 Java并发包中线程同步器原理剖析
      • 10.1 CountDownLatch原理剖析
  • 第三部分 Java并发编程实践篇
    • 第11章 并发编程实践
      • 11.1 ArrayBlockingQueue的使用
      • 11.3 并发组件ConcurrentHashMap使用注意事项
      • 11.4 SimpleDateFormat是线程不安全的
      • 11.7 创建线程和线程池时需要指定与业务相关的名称
      • 11.8 使用线程池的情况下当程序结束时记得调用shutdown关闭线程池
      • 11.9 线程池使用FutureTask时需要注意的事情
      • 11.10 使用ThreadLocal不当可能会导致内存泄漏

前言

本博客是对这本书的补充。

第一部分 Java并发编程基础篇

第1章 并发编程线程基础

1.1 什么是线程

JVM内存区域(运行时数据区域)

1.2 线程创建与运行

public class Thread implements Runnable {
	/* What will be run. */
    private Runnable target;
	
	/* ThreadLocal values pertaining to this thread. This map is maintained
     * by the ThreadLocal class. 
     * 与此线程有关的ThreadLocal值。该映射由ThreadLocal类维护。*/
    ThreadLocal.ThreadLocalMap threadLocals = null;

	/*
     * InheritableThreadLocal values pertaining to this thread. This map is
     * maintained by the InheritableThreadLocal class.
     * 与此线程有关的InheritableThreadLocal值。该映射由InheritableThreadLocal类维护
     */
    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
    
	/* Java thread status for tools,
     * initialized to indicate thread 'not yet started'
     * 线程的状态,涉及到Thread类的内部枚举类:State(线程的六种状态)
     */
    private volatile int threadStatus = 0;

	/**
     * The argument supplied to the current call to
     * java.util.concurrent.locks.LockSupport.park.
     * Set by (private) java.util.concurrent.locks.LockSupport.setBlocker
     * Accessed using java.util.concurrent.locks.LockSupport.getBlocker
     * 提供给LockSupport.park的当前调用的参数。 由(私有)LockSupport.setBlocker设置,使用LockSupport.getBlocker进行访问  
     */
    volatile Object parkBlocker;

	/** The current seed for a ThreadLocalRandom */
    @sun.misc.Contended("tlr")
    long threadLocalRandomSeed;

    /** Probe hash value; nonzero if threadLocalRandomSeed initialized */
    @sun.misc.Contended("tlr")
    int threadLocalRandomProbe;

	public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }
	
	public Thread() {
        init(null, null, "Thread-" + nextThreadNum(), 0);
    }

	@Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
}

分析代码可知:

  • Thread类实现了Runnable接口
  • Thread类有个属性:Runnable target,默认为null,
  • Thread类有两个主要的构造函数new Thread(Runnable target)、new Thread(),前面的那个会将target参数赋值给target属性
  • Thread类的run()方法:若target不为null,就执行target.run(),否则啥也不做。
    所以创建线程应该是有两种方式:要么使用new Thread(Runnable target):直接传入Runnable对象;要么使用new Thread():定义一个Thread的子类并重写run()方法,改为要执行的任务的具体逻辑,而不再使用target属性。至于书中说的FutureTask方式其实也是使用new Thread(Runnable target):因为FutureTask是Runnable的实现类,所以可以使用new Thread(FutureTask futureTask)。
public interface RunnableFuture<V> extends Runnable, Future<V> {
	/**
     * Sets this Future to the result of its computation
     * unless it has been cancelled.
     */
    void run();
}

public class FutureTask<V> implements RunnableFuture<V> {
	/** The underlying callable; nulled out after running */
    private Callable<V> callable;
    
	public FutureTask(Callable<V> callable) { this.callable = callable; }
}

1.3 线程通知与等待

为什么wait/notify/notifyAll必须要放在synchronized中

参考为什么wait/notify必须要强制要求放在synchronized中

另外,调用这三个方法之前必须拿要到当前锁对象的监视器monitor对象,也就是说notify/notifyAll和wait方法依赖于monitor对象,而monitor存在于对象头的Mark Word中(存储monitor引用指针),而synchronized关键字可以获取monitor ,所以,notify/notifyAll和wait方法必须在synchronized代码块或者synchronized方法中调用。

线程的六种状态

1.4 等待线程执行终止的join方法

1.5 让线程睡眠的sleep方法

1.6 让出CPU执行权的yield方法

1.7 线程中断

1.8 理解线程上下文切换

1.9 线程死锁

1.11 ThreadLocal

强引用、软引用、弱引用、虚引用

参考Java:强引用,软引用,弱引用和虚引用

第2章 并发编程的其他基础知识

2.9 Unsafe类

Unsafe只提供了三种CAS方法,compareAndSwapObject, compareAndSwapInt和compareAndSwapLong。其它方法都是基于这三个方法实现的。而AtomicLong又是对Unsafe的使用的进一步封装。

Unsafe为什么不安全

具体表现就是可以直接操作内存,而不做任何安全校验,如果有问题,则会在运行时抛出 Fatal Error,导致整个虚拟机的退出

Unsafe类与反射去区别

见第3章

第二部分 Java并发编程高级篇

第3章 Java并发包中ThreadLocalRandom类原理剖析

注意:ThreadLocalRandom只是类似与ThreadLocal,但没有使用ThreadLocal来实现线程间数据隔离,而是使用Thread类专门提供的属性threadLocalRandomSeed+使用Unsafe操作这个属性实现的。

ThreadLocalRandom 为什么非要使用 Unsafe 来修改 Thread 对象内的随机种子?

Thread类的threadLocalRandomSeed属性是没有任何访问权限修饰符的,Threa类也没有提供 get/set 方法(为了不违反类的封闭性原则),所以只能在Thread类所在包下的类才能访问Thread的这个属性。而Thread位于java.lang包,ThreadLocalRandom位于java.util.concurrent包,因此ThreadLocalRandom并没有办法访问Thread的threadLocalRandomSeed等变量。

反射是一种可以绕过封装,直接访问对象内部数据的方法,但是,反射的性能不太好,并不适合作为一个高性能的解决方案。

有没有什么办法可以让ThreadLocalRandom访问Thread的内部成员,同时又具有远超于反射的,且无限接近于直接变量访问的方法呢?答案是肯定的,这就是使用Unsafe类。这类类似C的操作方法(直接操作内存),带来了极大的性能提升,更重要的是,由于它避开了字段名,直接使用偏移量,就可以轻松绕过成员的可见性限制了。所以JDK源码中大量使用Unsafe类,而不是反射!

第4章 Java并发包中原子操作类原理剖析

4.1 原子变量操作类

JUC包中有AtomicInteger、AtomicLong和AtomicBoolean等原子性操作类,它们原理类似,下面以AtomicLong为例进行讲解。

4.2 JDK 8新增的原子操作类LongAdder

第6章 Java并发包中锁原理剖析

6.1 LockSupport工具类

直接使用Unsafe还是不太放便,因此lock包提供了一个辅助类LockSupport封装了park和unpark。使用LockSupport要比直接只用Unsafe更加便捷。此外,LockSupport还可以用来给线程设置一个Blocker对象,便于调试和检测线程,其原理是使用Unsafe的putObject方法直接设置Thread对象的parkBlocker属性,并在合适的时候读取这个Blocker对象

LockSupport类源码:

public class LockSupport {
	private static final sun.misc.Unsafe UNSAFE;
    private static final long parkBlockerOffset;
    
	static {
        try {
            UNSAFE = sun.misc.Unsafe.getUnsafe();
            Class<?> tk = Thread.class;
            parkBlockerOffset = UNSAFE.objectFieldOffset(tk.getDeclaredField("parkBlocker"));
        } catch (Exception ex) { throw new Error(ex); }
    }
    
	private LockSupport() {} // Cannot be instantiated.
	
	public static void park() {
        UNSAFE.park(false, 0L);
    }

	public static void parkNanos(long nanos) {
        if (nanos > 0)
            UNSAFE.park(false, nanos);
    }
    
	public static void park(Object blocker) {
        Thread t = Thread.currentThread();
        setBlocker(t, blocker);
        UNSAFE.park(false, 0L);
        setBlocker(t, null);
    }

	public static void parkNanos(Object blocker, long nanos) {
        if (nanos > 0) {
            Thread t = Thread.currentThread();
            setBlocker(t, blocker);
            UNSAFE.park(false, nanos);
            setBlocker(t, null);
        }
    }
    
	private static void setBlocker(Thread t, Object arg) {
	    // Even though volatile, hotspot doesn't need a write barrier here.
	    UNSAFE.putObject(t, parkBlockerOffset, arg);
	}
	
	public static Object getBlocker(Thread t) {
        if (t == null)
            throw new NullPointerException();
        return UNSAFE.getObjectVolatile(t, parkBlockerOffset);
    }
	
	public static void unpark(Thread thread) {
        if (thread != null)
            UNSAFE.unpark(thread);
    }
}

6.2 抽象同步队列aqs概述

6.2.1 AQS——锁的底层支持

详细分析结点状态waitStatus和public final void acquire(int arg)方法和public final boolean release(int)方法。参考Java并发之AQS详解

分析Node的nextWaiter属性。

	static final class Node {
		/** 指示节点正在共享模式下等待的标记 */
	    static final Node SHARED = new Node();
	    /** 指示节点正在以独占模式等待的标记 */
	    static final Node EXCLUSIVE = null;

		/** waitStatus值,指示线程已取消 */
        static final int CANCELLED =  1;
        /** waitStatus值,指示下一个节点中的线程需要unpark */
        static final int SIGNAL    = -1;
        /** waitStatus值,指示线程正在condition上等待 */
        static final int CONDITION = -2;
        /**  waitStatus值指示下一个acquireShared应无条件传播 */
        static final int PROPAGATE = -3;
		
		volatile int waitStatus;
		
		/**
         * 指向条件队列的下一个节点,或是特殊值:SHARED。因为条件队列只有在保持在独占模式时才被访问,
         * 所以节点在condition上等待时我们只需要一个简单的链接队列来保存它们即可。然后将它们转移到队列中以re-acquire。
         * 并且因为条件只能是独占模式的,我们通过使用特殊的值来保存一个字段来指示共享模式。
         * 

在当前Node对象作为Condition的等待队列节点使用时,nextWaiter属性保存后继节点。 *

在当前Node对象作为同步队列节点时,nextWaiter属性可能有两个值:{@link #EXCLUSIVE}、{@link #SHARED} 标识当前节点是独占模式还是共享模式,见{@link #Node(Thread, Node)},{@link #isShared()}; */ Node nextWaiter; }

6.2.2 AQS——条件变量的支持

分析ConditionObject的源码

	/**
     *  如果同步相对于当前(调用)线程排他地保持,则返回{@code true}。每次调用不等待的{@link ConditionObject}方法时,将调用此方法。
     *  (等待方法调用{@link #release}。)。
     * 
     *  

默认实现会抛出{@link UnsupportedOperationException}。 * 此方法仅在{@link ConditionObject}方法内部调用,因此如果不使用条件,则不需要定义。 */ protected boolean isHeldExclusively() { throw new UnsupportedOperationException(); } public class ConditionObject implements Condition, java.io.Serializable { /** First node of condition queue. */ private transient Node firstWaiter; /** Last node of condition queue. */ private transient Node lastWaiter; /** * 将等待时间最长的线程(如果存在)从此条件的等待队列移动到拥有锁的等待队列。 */ public final void signal() { //若当前线程未拥有锁,就抛异常 if (!isHeldExclusively()) throw new IllegalMonitorStateException(); Node first = firstWaiter; if (first != null) doSignal(first); } private void doSignal(Node first) { do { if ( (firstWaiter = first.nextWaiter) == null) lastWaiter = null; first.nextWaiter = null; } while (!transferForSignal(first) && (first = firstWaiter) != null); } /** * 将节点从条件队列移到同步队列。如果成功,返回true。 */ final boolean transferForSignal(Node node) { /* * If cannot change waitStatus, the node has been cancelled. *

* 如果无法更改waitStatus,则该节点已取消。 * */ if (!compareAndSetWaitStatus(node, Node.CONDITION, 0)) return false; /* * Splice onto queue and try to set waitStatus of predecessor to * indicate that thread is (probably) waiting. If cancelled or * attempt to set waitStatus fails, wake up to resync (in which * case the waitStatus can be transiently and harmlessly wrong). *

* 接合到队列并尝试设置前导的waitStatus以指示线程(可能)等待。如果取消或尝试设置waitStatus失败,唤醒以重新同步(在这种情况下,waitStatus可能会暂时和无害地错误)。 * */ Node p = enq(node); int ws = p.waitStatus; if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL)) LockSupport.unpark(node.thread); return true; } }

6.2.3 基于AQS实现自定义同步器

6.3 ReentrantLock的原理

6.3.1 类图结构
6.3.2 获取锁

梳理ReentrantLock#lock()的底层调用关系

public class ReentrantLock implements Lock, java.io.Serializable {
	public void lock() {
        sync.lock();
    }

	abstract static class Sync extends AbstractQueuedSynchronizer {
        /**
         * Performs {@link Lock#lock}. The main reason for subclassing
         * is to allow fast path for nonfair version.
         */
        abstract void lock();
    }
	
	static final class NonfairSync extends Sync {
        /**
         *  执行锁定。尝试立即插入,在故障时备份到正常获取。
         */
        final void lock() {
            //采用cas将AQS中的state从0变为1
            if (compareAndSetState(0, 1))
            /**
             * 在ReentrantLock语境下,state代表锁被重入的次数,这意味着只有当前锁未被任何线程持有时该动作才会返回成功.
             * 获取锁成功后,将当前线程标记成为当前锁的线程,此时,加锁流程结束
             */
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
		
		final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }
}

分析公平锁与非公平锁的tryAcquire()和tryRelease()代码的区别。

6.3.3 释放锁

6.4 读写锁ReentrantReadWriteLock原理

6.4.1 类图结构
6.4.2 写锁的获取与释放
6.4.3 读锁的获取与释放
6.4.4 案例介绍

6.5 JDK 8中新增的StampedLock锁探究

第7章 Java并发包中并发队列原理剖析

7.1 ConcurrentLinkedQueue原理探究

使用单向链表(head:Node[item、next]、tail:Node[item、next])方式实现的无界非阻塞(CAS)队列

7.2 LinkedBlockingQueue原理探究

使用单向链表(head:Node[item、next]、tail:Node[item、next])方式实现的无界(Integer.MAX)阻塞(ReentrantLock)队列。有takeLock(内部有notEmpty条件变量)、putLock(内部有notFull条件变量)

7.3 ArrayBlockingQueue原理探究

使用有界数组(items:Objet[])方式实现的阻塞(ReentrantLock)队列。只有一个独占锁lock用来保证出、入队操作的原子性,这保证了同时只有一个线程可以进行入队、出队操作。

第8章 Java并发包中线程池ThreadPoolExecutor原理探究

8.1 介绍

8.2 类图介绍

8.3 源码分析

补充ThreadPoolExecutor继承的ExecutorService#awaitTermination()。一般是shutdown()后马上调用该方法,调用该方法会阻塞当前线程,直到调用shutdown()后所有任务完成执行,或者发生超时,或者当前线程被中断(以先发生者为准)。

合理配置线程池

8.4 总结

第9章 Java并发包中ScheduledThreadPoolExecutor原理探究

第10章 Java并发包中线程同步器原理剖析

10.1 CountDownLatch原理剖析

调用一个子线程的join()方法后,该线程会一直被阻塞直到子线程运行完毕,而CountDownLatch则使用计数器来允许子线程运行完毕或者在运行中递减计数,也就是CountDownLatch可以在子线程运行的任何时候让await方法返回而不一定必须等到线程结束

书中说"使用ExecutorService时传递的参数是Runable或者Callable对象,这时候你没有办法直接调用这些线程的join()方法,这就需要选择使用CountDownLatch了"。其实也可以选择使用ExecutorService#shutdown()。我的理解是:第一、若要在子线程执行的某一时刻就能唤醒父线程,就只能使用CountDownLatch;第二、若创建ExecutorService时不知道累积要执行多少个子线程任务,就只能用ExecutorService#shutdown()

CountDownLatch是使用AQS实现的。使用AQS的状态变量来存放计数器的值。

第三部分 Java并发编程实践篇

第11章 并发编程实践

11.1 ArrayBlockingQueue的使用

11.3 并发组件ConcurrentHashMap使用注意事项

11.4 SimpleDateFormat是线程不安全的

11.7 创建线程和线程池时需要指定与业务相关的名称

11.8 使用线程池的情况下当程序结束时记得调用shutdown关闭线程池

11.9 线程池使用FutureTask时需要注意的事情

11.10 使用ThreadLocal不当可能会导致内存泄漏

你可能感兴趣的:(#,多线程,java,并发编程,多线程)